@codingame/monaco-vscode-api 1.79.2-next.1 → 1.79.2-next.2

package/dist/extensions.d.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { a as IExtensionDescription, b as IExtensionManifest } from './extensions.d2.ts';
+import { b as IExtensionDescription, I as IExtensionManifest } from './extensions.d2.ts';
 export { c as IExtensionContributions } from './extensions.d2.ts';
 import { I as IMessage } from './extensionsRegistry.js';
 import { a as IDisposable } from './event.js';

package/dist/extensions.d2.ts

@@ -443,4 +443,4 @@ interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
 }
 type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
 
-export { ExtensionIdentifier as E, ILocalizedString as I, TargetPlatform as T, IExtensionDescription as a, IExtensionManifest as b, IExtensionContributions as c, ExtensionKind as d, ICommandAction as e, ICommandActionTitle as f, Icon as g, IEnvironmentService as h };
+export { ExtensionIdentifier as E, IExtensionManifest as I, TargetPlatform as T, ILocalizedString as a, IExtensionDescription as b, IExtensionContributions as c, ExtensionKind as d, ICommandAction as e, ICommandActionTitle as f, Icon as g, IEnvironmentService as h };

package/dist/extensionsRegistry.d.ts

@@ -1,5 +1,5 @@
 import { S as ServiceIdentifier } from './instantiation.js';
-import { E as ExtensionIdentifier, a as IExtensionDescription, c as IExtensionContributions, d as ExtensionKind } from './extensions.d2.ts';
+import { E as ExtensionIdentifier, b as IExtensionDescription, c as IExtensionContributions, d as ExtensionKind } from './extensions.d2.ts';
 import { E as Event } from './event.js';
 import { S as Severity } from './severity.js';
 

package/dist/rollup-extension-directory-plugin.d.ts

@@ -1,13 +1,21 @@
 import { FilterPattern } from '@rollup/pluginutils';
 import { Plugin, InputPluginOption } from 'rollup';
+import { I as IExtensionManifest } from './extensions.d2.ts';
+import './uri.js';
+import './contextkey.js';
+import './instantiation.js';
+import './event.js';
+import 'vscode';
+import './themables.js';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
     isDefaultExtension?: boolean;
     withCode?: (extensionPath: string) => boolean;
-    rollupPlugins: InputPluginOption[];
+    rollupPlugins?: InputPluginOption[];
+    transformManifest?: (manifest: IExtensionManifest) => IExtensionManifest;
 }
-declare function plugin({ include, exclude, isDefaultExtension, withCode, rollupPlugins }: Options): Plugin;
+declare function plugin({ include, exclude, isDefaultExtension, withCode, rollupPlugins, transformManifest }: Options): Plugin;
 
 export { plugin as default };

package/dist/rollup-extension-directory-plugin.js

@@ -11,7 +11,7 @@ import 'node:crypto';
 import 'node:fs/promises';
 import 'tty';
 
-function plugin({ include, exclude, isDefaultExtension = false, withCode = () => true, rollupPlugins }) {
+function plugin({ include, exclude, isDefaultExtension = false, withCode = () => true, rollupPlugins = [], transformManifest = manifest => manifest }) {
     const filter = createFilter(include, exclude);
     return {
         name: 'default-extensions-loader',
@@ -36,7 +36,7 @@ function plugin({ include, exclude, isDefaultExtension = false, withCode = () =>
                     parsed = localizeManifest(parsed, parseJson(id, (await fsPromise.readFile(nlsFile)).toString()));
                 }
                 return {
-                    code: dataToEsm(parsed, {
+                    code: dataToEsm(transformManifest(parsed), {
                         compact: true,
                         namedExports: false,
                         preferConst: false

package/dist/rollup-vsix-plugin.d.ts

@@ -1,12 +1,20 @@
 import { FilterPattern } from '@rollup/pluginutils';
 import { Plugin, InputPluginOption } from 'rollup';
+import { I as IExtensionManifest } from './extensions.d2.ts';
+import './uri.js';
+import './contextkey.js';
+import './instantiation.js';
+import './event.js';
+import 'vscode';
+import './themables.js';
 
 interface Options {
     include?: FilterPattern;
     exclude?: FilterPattern;
     withCode?: (extensionPath: string) => boolean;
-    rollupPlugins: InputPluginOption[];
+    rollupPlugins?: InputPluginOption[];
+    transformManifest?: (manifest: IExtensionManifest) => IExtensionManifest;
 }
-declare function plugin({ include, exclude, rollupPlugins, withCode }: Options): Plugin;
+declare function plugin({ include, exclude, rollupPlugins, withCode, transformManifest }: Options): Plugin;
 
 export { plugin as default };

package/dist/rollup-vsix-plugin.js

@@ -53,7 +53,7 @@ async function readVsix(file) {
 function getVsixPath(file) {
     return path.relative('/', path.resolve('/', file));
 }
-function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () => true }) {
+function plugin({ include = '**/*.vsix', exclude, rollupPlugins = [], withCode = () => true, transformManifest = manifest => manifest }) {
     const filter = createFilter(include, exclude);
     const vsixFiles = {};
     return {
@@ -100,11 +100,13 @@ function plugin({ include = '**/*.vsix', exclude, rollupPlugins, withCode = () =
                 const file = match[2];
                 const vsixFile = vsixFiles[match[1]];
                 let parsed = parseJson(id, vsixFile[file].toString('utf8'));
-                if (file === 'package.json' && 'package.nls.json' in vsixFile) {
-                    parsed = localizeManifest(parsed, parseJson(id, vsixFile['package.nls.json'].toString()));
+                if (file === 'package.json') {
+                    if ('package.nls.json' in vsixFile) {
+                        parsed = localizeManifest(parsed, parseJson(id, vsixFile['package.nls.json'].toString()));
+                    }
                 }
                 return {
-                    code: dataToEsm(parsed, {
+                    code: dataToEsm(transformManifest(parsed), {
                         compact: true,
                         namedExports: false,
                         preferConst: false

package/dist/services.d.ts

@@ -19,7 +19,7 @@ import { I as IconIdentifier, T as ThemeIcon } from './themables.js';
 import { I as IJSONSchema, a as IJSONSchemaMap } from './jsonSchema.js';
 import { I as IView$3, a as IViewDescriptorService, b as IViewPaneContainer, c as ViewContainer, d as IViewContainerModel, e as IViewDescriptor, f as IAddedViewDescriptorRef, g as IPaneComposite, V as ViewContainerLocation } from './views.js';
 export { h as IViewsService } from './views.js';
-import { e as ICommandAction, f as ICommandActionTitle, g as Icon, h as IEnvironmentService, E as ExtensionIdentifier, T as TargetPlatform, a as IExtensionDescription } from './extensions.d2.ts';
+import { e as ICommandAction, f as ICommandActionTitle, g as Icon, h as IEnvironmentService, E as ExtensionIdentifier, T as TargetPlatform, b as IExtensionDescription } from './extensions.d2.ts';
 import { b as IProgress, c as IProgressStep, I as IComposite, d as ICompositeControl, a as IProgressIndicator } from './composite.js';
 import { a as IContextKeyService, C as ContextKeyExpression } from './contextkey.js';
 import { a as IExtensionService } from './extensionsRegistry.js';

package/dist/views.d.ts

@@ -3,7 +3,7 @@ import { U as URI } from './uri.js';
 import { E as Event } from './event.js';
 import { T as ThemeIcon } from './themables.js';
 import { C as ContextKeyExpression } from './contextkey.js';
-import { I as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
+import { a as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
 import { I as IComposite, a as IProgressIndicator } from './composite.js';
 
 interface IKeybindings {

package/dist/vscode/vs/workbench/contrib/search/browser/search.contribution.js

@@ -21,6 +21,12 @@ import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/
 import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
 import { getWorkspaceSymbols } from '../common/search.js';
 import { ShowAllSymbolsActionId } from '../common/constants.js';
+import './searchActionsCopy.js';
+import './searchActionsFind.js';
+import './searchActionsNav.js';
+import './searchActionsRemoveReplace.js';
+import './searchActionsSymbol.js';
+import './searchActionsTopBar.js';
 registerContributions();
 registerContributions$1();
 const SEARCH_MODE_CONFIG = 'search.mode';

package/dist/vscode/vs/workbench/contrib/search/browser/searchActionsBase.js

@@ -1,5 +1,8 @@
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { searchComparer, FileMatch, Match, FolderMatch } from './searchModel.js';
 import { VIEW_ID } from '../../../services/search/common/search.js';
+const category = { value: ( nls.localize('search', "Search")), original: 'Search' };
 function isSearchViewFocused(viewsService) {
     const searchView = getSearchView(viewsService);
     const activeElement = document.activeElement;
@@ -11,7 +14,33 @@ function appendKeyBindingLabel(label, inputKeyBinding) {
 function getSearchView(viewsService) {
     return viewsService.getActiveViewWithId(VIEW_ID);
 }
+function getElementsToOperateOn(viewer, currElement, sortConfig) {
+    let elements = viewer.getSelection().filter((x) => x !== null).sort((a, b) => searchComparer(a, b, sortConfig.sortOrder));
+    if (currElement && !(elements.length > 1 && elements.includes(currElement))) {
+        elements = [currElement];
+    }
+    return elements;
+}
+function shouldRefocus(elements, focusElement) {
+    if (!focusElement) {
+        return false;
+    }
+    return !focusElement || elements.includes(focusElement) || hasDownstreamMatch(elements, focusElement);
+}
+function hasDownstreamMatch(elements, focusElement) {
+    for (const elem of elements) {
+        if ((elem instanceof FileMatch && focusElement instanceof Match && elem.matches().includes(focusElement)) ||
+            (elem instanceof FolderMatch && ((focusElement instanceof FileMatch && elem.getDownstreamFileMatch(focusElement.resource)) ||
+                (focusElement instanceof Match && elem.getDownstreamFileMatch(focusElement.parent().resource))))) {
+            return true;
+        }
+    }
+    return false;
+}
+function openSearchView(viewsService, focus) {
+    return viewsService.openView(VIEW_ID, focus).then(view => (view ?? undefined));
+}
 function doAppendKeyBindingLabel(label, keyBinding) {
     return keyBinding ? label + ' (' + keyBinding.getLabel() + ')' : label;
 }
-export { appendKeyBindingLabel, getSearchView, isSearchViewFocused };
+export { appendKeyBindingLabel, category, getElementsToOperateOn, getSearchView, isSearchViewFocused, openSearchView, shouldRefocus };

package/dist/vscode/vs/workbench/contrib/search/browser/searchActionsCopy.js

@@ -0,0 +1,204 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IViewsService } from '../../../common/views.js';
+import { CopyMatchCommandId, FileMatchOrMatchFocusKey, CopyPathCommandId, FileMatchOrFolderMatchWithResourceFocusKey, CopyAllCommandId, HasSearchResults } from '../common/constants.js';
+import { FileMatch, FolderMatchWithResource, Match, FolderMatch, searchMatchComparer } from './searchModel.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { category, getSearchView } from './searchActionsBase.js';
+import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+registerAction2(class CopyMatchCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: CopyMatchCommandId,
+            title: {
+                value: ( nls.localize('copyMatchLabel', "Copy")),
+                original: 'Copy'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: FileMatchOrMatchFocusKey,
+                primary: 2048  | 33 ,
+            },
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: FileMatchOrMatchFocusKey,
+                    group: 'search_2',
+                    order: 1
+                }]
+        });
+    }
+    async run(accessor, match) {
+        await copyMatchCommand(accessor, match);
+    }
+});
+registerAction2(class CopyPathCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: CopyPathCommandId,
+            title: {
+                value: ( nls.localize('copyPathLabel', "Copy Path")),
+                original: 'Copy Path'
+            },
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: FileMatchOrFolderMatchWithResourceFocusKey,
+                primary: 2048  | 512  | 33 ,
+                win: {
+                    primary: 1024  | 512  | 33
+                },
+            },
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: FileMatchOrFolderMatchWithResourceFocusKey,
+                    group: 'search_2',
+                    order: 2
+                }]
+        });
+    }
+    async run(accessor, fileMatch) {
+        await copyPathCommand(accessor, fileMatch);
+    }
+});
+registerAction2(class CopyAllCommandAction extends Action2 {
+    constructor() {
+        super({
+            id: CopyAllCommandId,
+            title: {
+                value: ( nls.localize('copyAllLabel', "Copy All")),
+                original: 'Copy All'
+            },
+            category,
+            menu: [{
+                    id: MenuId.SearchContext,
+                    when: HasSearchResults,
+                    group: 'search_2',
+                    order: 3
+                }]
+        });
+    }
+    async run(accessor) {
+        await copyAllCommand(accessor);
+    }
+});
+const lineDelimiter = isWindows ? '\r\n' : '\n';
+async function copyPathCommand(accessor, fileMatch) {
+    if (!fileMatch) {
+        const selection = getSelectedRow(accessor);
+        if (!(selection instanceof FileMatch || selection instanceof FolderMatchWithResource)) {
+            return;
+        }
+        fileMatch = selection;
+    }
+    const clipboardService = accessor.get(IClipboardService);
+    const labelService = accessor.get(ILabelService);
+    const text = labelService.getUriLabel(fileMatch.resource, { noPrefix: true });
+    await clipboardService.writeText(text);
+}
+async function copyMatchCommand(accessor, match) {
+    if (!match) {
+        const selection = getSelectedRow(accessor);
+        if (!selection) {
+            return;
+        }
+        match = selection;
+    }
+    const clipboardService = accessor.get(IClipboardService);
+    const labelService = accessor.get(ILabelService);
+    let text;
+    if (match instanceof Match) {
+        text = matchToString(match);
+    }
+    else if (match instanceof FileMatch) {
+        text = fileMatchToString(match, labelService).text;
+    }
+    else if (match instanceof FolderMatch) {
+        text = folderMatchToString(match, labelService).text;
+    }
+    if (text) {
+        await clipboardService.writeText(text);
+    }
+}
+async function copyAllCommand(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const clipboardService = accessor.get(IClipboardService);
+    const labelService = accessor.get(ILabelService);
+    const searchView = getSearchView(viewsService);
+    if (searchView) {
+        const root = searchView.searchResult;
+        const text = allFolderMatchesToString(root.folderMatches(), labelService);
+        await clipboardService.writeText(text);
+    }
+}
+function matchToString(match, indent = 0) {
+    const getFirstLinePrefix = () => `${match.range().startLineNumber},${match.range().startColumn}`;
+    const getOtherLinePrefix = (i) => match.range().startLineNumber + i + '';
+    const fullMatchLines = match.fullPreviewLines();
+    const largestPrefixSize = fullMatchLines.reduce((largest, _, i) => {
+        const thisSize = i === 0 ?
+            getFirstLinePrefix().length :
+            getOtherLinePrefix(i).length;
+        return Math.max(thisSize, largest);
+    }, 0);
+    const formattedLines = ( fullMatchLines
+        .map((line, i) => {
+        const prefix = i === 0 ?
+            getFirstLinePrefix() :
+            getOtherLinePrefix(i);
+        const paddingStr = ' '.repeat(largestPrefixSize - prefix.length);
+        const indentStr = ' '.repeat(indent);
+        return `${indentStr}${prefix}: ${paddingStr}${line}`;
+    }));
+    return formattedLines.join('\n');
+}
+function fileFolderMatchToString(match, labelService) {
+    if (match instanceof FileMatch) {
+        return fileMatchToString(match, labelService);
+    }
+    else {
+        return folderMatchToString(match, labelService);
+    }
+}
+function fileMatchToString(fileMatch, labelService) {
+    const matchTextRows = ( fileMatch.matches()
+        .sort(searchMatchComparer)
+        .map(match => matchToString(match, 2)));
+    const uriString = labelService.getUriLabel(fileMatch.resource, { noPrefix: true });
+    return {
+        text: `${uriString}${lineDelimiter}${matchTextRows.join(lineDelimiter)}`,
+        count: matchTextRows.length
+    };
+}
+function folderMatchToString(folderMatch, labelService) {
+    const results = [];
+    let numMatches = 0;
+    const matches = folderMatch.matches().sort(searchMatchComparer);
+    matches.forEach(match => {
+        const result = fileFolderMatchToString(match, labelService);
+        numMatches += result.count;
+        results.push(result.text);
+    });
+    return {
+        text: results.join(lineDelimiter + lineDelimiter),
+        count: numMatches
+    };
+}
+function allFolderMatchesToString(folderMatches, labelService) {
+    const folderResults = [];
+    folderMatches = folderMatches.sort(searchMatchComparer);
+    for (let i = 0; i < folderMatches.length; i++) {
+        const folderResult = folderMatchToString(folderMatches[i], labelService);
+        if (folderResult.count) {
+            folderResults.push(folderResult.text);
+        }
+    }
+    return folderResults.join(lineDelimiter + lineDelimiter);
+}
+function getSelectedRow(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const searchView = getSearchView(viewsService);
+    return searchView?.getControl().getSelection()[0];
+}
+export { lineDelimiter };