@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookExtensionPoint.js

@@ -8,235 +8,235 @@ import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/ser
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 
 const NotebookEditorContribution = ( Object.freeze({
-    type: 'type',
-    displayName: 'displayName',
-    selector: 'selector',
-    priority: 'priority',
+    type: "type",
+    displayName: "displayName",
+    selector: "selector",
+    priority: "priority"
 }));
 const NotebookRendererContribution = ( Object.freeze({
-    id: 'id',
-    displayName: 'displayName',
-    mimeTypes: 'mimeTypes',
-    entrypoint: 'entrypoint',
-    hardDependencies: 'dependencies',
-    optionalDependencies: 'optionalDependencies',
-    requiresMessaging: 'requiresMessaging',
+    id: "id",
+    displayName: "displayName",
+    mimeTypes: "mimeTypes",
+    entrypoint: "entrypoint",
+    hardDependencies: "dependencies",
+    optionalDependencies: "optionalDependencies",
+    requiresMessaging: "requiresMessaging"
 }));
 const NotebookPreloadContribution = ( Object.freeze({
-    type: 'type',
-    entrypoint: 'entrypoint',
-    localResourceRoots: 'localResourceRoots',
+    type: "type",
+    entrypoint: "entrypoint",
+    localResourceRoots: "localResourceRoots"
 }));
 const notebookProviderContribution = {
-    description: ( localize(9621, 'Contributes notebook document provider.')),
-    type: 'array',
-    defaultSnippets: [{ body: [{ type: '', displayName: '', 'selector': [{ 'filenamePattern': '' }] }] }],
+    description: ( localize(9941, "Contributes notebook document provider.")),
+    type: "array",
+    defaultSnippets: [{
+        body: [{
+            type: "",
+            displayName: "",
+            "selector": [{
+                "filenamePattern": ""
+            }]
+        }]
+    }],
     items: {
-        type: 'object',
+        type: "object",
         required: [
             NotebookEditorContribution.type,
             NotebookEditorContribution.displayName,
-            NotebookEditorContribution.selector,
+            NotebookEditorContribution.selector
         ],
         properties: {
             [NotebookEditorContribution.type]: {
-                type: 'string',
-                description: ( localize(9622, 'Type of the notebook.')),
+                type: "string",
+                description: ( localize(9942, "Type of the notebook."))
             },
             [NotebookEditorContribution.displayName]: {
-                type: 'string',
-                description: ( localize(9623, 'Human readable name of the notebook.')),
+                type: "string",
+                description: ( localize(9943, "Human readable name of the notebook."))
             },
             [NotebookEditorContribution.selector]: {
-                type: 'array',
-                description: ( localize(9624, 'Set of globs that the notebook is for.')),
+                type: "array",
+                description: ( localize(9944, "Set of globs that the notebook is for.")),
                 items: {
-                    type: 'object',
+                    type: "object",
                     properties: {
                         filenamePattern: {
-                            type: 'string',
-                            description: ( localize(9625, 'Glob that the notebook is enabled for.')),
+                            type: "string",
+                            description: ( localize(9945, "Glob that the notebook is enabled for."))
                         },
                         excludeFileNamePattern: {
-                            type: 'string',
-                            description: ( localize(9626, 'Glob that the notebook is disabled for.'))
+                            type: "string",
+                            description: ( localize(9946, "Glob that the notebook is disabled for."))
                         }
                     }
                 }
             },
             [NotebookEditorContribution.priority]: {
-                type: 'string',
+                type: "string",
                 markdownDeprecationMessage: ( localize(
-                    9627,
-                    'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
+                    9947,
+                    "Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting."
                 )),
-                enum: [
-                    NotebookEditorPriority.default,
-                    NotebookEditorPriority.option,
-                ],
-                markdownEnumDescriptions: [
-                    ( localize(
-                    9628,
-                    'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
-                )),
-                    ( localize(
-                    9629,
-                    'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
-                )),
-                ],
-                default: 'default'
+                enum: [NotebookEditorPriority.default, NotebookEditorPriority.option],
+                markdownEnumDescriptions: [( localize(
+                    9948,
+                    "The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource."
+                )), ( localize(
+                    9949,
+                    "The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command."
+                ))],
+                default: "default"
             }
         }
     }
 };
-const defaultRendererSnippet = ( Object.freeze({ id: '', displayName: '', mimeTypes: [''], entrypoint: '' }));
+const defaultRendererSnippet = ( Object.freeze({
+    id: "",
+    displayName: "",
+    mimeTypes: [""],
+    entrypoint: ""
+}));
 const notebookRendererContribution = {
-    description: ( localize(9630, 'Contributes notebook output renderer provider.')),
-    type: 'array',
-    defaultSnippets: [{ body: [defaultRendererSnippet] }],
+    description: ( localize(9950, "Contributes notebook output renderer provider.")),
+    type: "array",
+    defaultSnippets: [{
+        body: [defaultRendererSnippet]
+    }],
     items: {
-        defaultSnippets: [{ body: defaultRendererSnippet }],
-        allOf: [
-            {
-                type: 'object',
-                required: [
-                    NotebookRendererContribution.id,
-                    NotebookRendererContribution.displayName,
-                ],
-                properties: {
-                    [NotebookRendererContribution.id]: {
-                        type: 'string',
-                        description: ( localize(9631, 'Unique identifier of the notebook output renderer.')),
+        defaultSnippets: [{
+            body: defaultRendererSnippet
+        }],
+        allOf: [{
+            type: "object",
+            required: [NotebookRendererContribution.id, NotebookRendererContribution.displayName],
+            properties: {
+                [NotebookRendererContribution.id]: {
+                    type: "string",
+                    description: ( localize(9951, "Unique identifier of the notebook output renderer."))
+                },
+                [NotebookRendererContribution.displayName]: {
+                    type: "string",
+                    description: ( localize(9952, "Human readable name of the notebook output renderer."))
+                },
+                [NotebookRendererContribution.hardDependencies]: {
+                    type: "array",
+                    uniqueItems: true,
+                    items: {
+                        type: "string"
                     },
-                    [NotebookRendererContribution.displayName]: {
-                        type: 'string',
-                        description: ( localize(9632, 'Human readable name of the notebook output renderer.')),
-                    },
-                    [NotebookRendererContribution.hardDependencies]: {
-                        type: 'array',
-                        uniqueItems: true,
-                        items: { type: 'string' },
-                        markdownDescription: ( localize(
-                            9633,
-                            'List of kernel dependencies the renderer requires. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer can be used.'
-                        )),
-                    },
-                    [NotebookRendererContribution.optionalDependencies]: {
-                        type: 'array',
-                        uniqueItems: true,
-                        items: { type: 'string' },
-                        markdownDescription: ( localize(
-                            9634,
-                            'List of soft kernel dependencies the renderer can make use of. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer will be preferred over renderers that don\'t interact with the kernel.'
-                        )),
-                    },
-                    [NotebookRendererContribution.requiresMessaging]: {
-                        default: 'never',
-                        enum: [
-                            'always',
-                            'optional',
-                            'never',
-                        ],
-                        enumDescriptions: [
-                            ( localize(
-                            9635,
-                            'Messaging is required. The renderer will only be used when it\'s part of an extension that can be run in an extension host.'
-                        )),
-                            ( localize(
-                            9636,
-                            'The renderer is better with messaging available, but it\'s not requried.'
-                        )),
-                            ( localize(9637, 'The renderer does not require messaging.')),
-                        ],
-                        description: ( localize(
-                            9638,
-                            'Defines how and if the renderer needs to communicate with an extension host, via `createRendererMessaging`. Renderers with stronger messaging requirements may not work in all environments.'
-                        )),
+                    markdownDescription: ( localize(
+                        9953,
+                        "List of kernel dependencies the renderer requires. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer can be used."
+                    ))
+                },
+                [NotebookRendererContribution.optionalDependencies]: {
+                    type: "array",
+                    uniqueItems: true,
+                    items: {
+                        type: "string"
                     },
+                    markdownDescription: ( localize(
+                        9954,
+                        "List of soft kernel dependencies the renderer can make use of. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer will be preferred over renderers that don't interact with the kernel."
+                    ))
+                },
+                [NotebookRendererContribution.requiresMessaging]: {
+                    default: "never",
+                    enum: ["always", "optional", "never"],
+                    enumDescriptions: [( localize(
+                        9955,
+                        "Messaging is required. The renderer will only be used when it's part of an extension that can be run in an extension host."
+                    )), ( localize(
+                        9956,
+                        "The renderer is better with messaging available, but it's not requried."
+                    )), ( localize(9957, "The renderer does not require messaging."))],
+                    description: ( localize(
+                        9958,
+                        "Defines how and if the renderer needs to communicate with an extension host, via `createRendererMessaging`. Renderers with stronger messaging requirements may not work in all environments."
+                    ))
                 }
-            },
-            {
-                oneOf: [
-                    {
-                        required: [
-                            NotebookRendererContribution.entrypoint,
-                            NotebookRendererContribution.mimeTypes,
-                        ],
-                        properties: {
-                            [NotebookRendererContribution.mimeTypes]: {
-                                type: 'array',
-                                description: ( localize(9639, 'Set of globs that the notebook is for.')),
-                                items: {
-                                    type: 'string'
-                                }
-                            },
-                            [NotebookRendererContribution.entrypoint]: {
-                                description: ( localize(9640, 'File to load in the webview to render the extension.')),
-                                type: 'string',
-                            },
+            }
+        }, {
+            oneOf: [{
+                required: [
+                    NotebookRendererContribution.entrypoint,
+                    NotebookRendererContribution.mimeTypes
+                ],
+                properties: {
+                    [NotebookRendererContribution.mimeTypes]: {
+                        type: "array",
+                        description: ( localize(9959, "Set of globs that the notebook is for.")),
+                        items: {
+                            type: "string"
                         }
                     },
-                    {
-                        required: [
-                            NotebookRendererContribution.entrypoint,
-                        ],
+                    [NotebookRendererContribution.entrypoint]: {
+                        description: ( localize(9960, "File to load in the webview to render the extension.")),
+                        type: "string"
+                    }
+                }
+            }, {
+                required: [NotebookRendererContribution.entrypoint],
+                properties: {
+                    [NotebookRendererContribution.entrypoint]: {
+                        description: ( localize(9960, "File to load in the webview to render the extension.")),
+                        type: "object",
+                        required: ["extends", "path"],
                         properties: {
-                            [NotebookRendererContribution.entrypoint]: {
-                                description: ( localize(9640, 'File to load in the webview to render the extension.')),
-                                type: 'object',
-                                required: ['extends', 'path'],
-                                properties: {
-                                    extends: {
-                                        type: 'string',
-                                        description: ( localize(9641, 'Existing renderer that this one extends.')),
-                                    },
-                                    path: {
-                                        type: 'string',
-                                        description: ( localize(9640, 'File to load in the webview to render the extension.')),
-                                    },
-                                }
+                            extends: {
+                                type: "string",
+                                description: ( localize(9961, "Existing renderer that this one extends."))
                             },
+                            path: {
+                                type: "string",
+                                description: ( localize(9960, "File to load in the webview to render the extension."))
+                            }
                         }
                     }
-                ]
-            }
-        ]
+                }
+            }]
+        }]
     }
 };
 const notebookPreloadContribution = {
-    description: ( localize(9642, 'Contributes notebook preloads.')),
-    type: 'array',
-    defaultSnippets: [{ body: [{ type: '', entrypoint: '' }] }],
+    description: ( localize(9962, "Contributes notebook preloads.")),
+    type: "array",
+    defaultSnippets: [{
+        body: [{
+            type: "",
+            entrypoint: ""
+        }]
+    }],
     items: {
-        type: 'object',
-        required: [
-            NotebookPreloadContribution.type,
-            NotebookPreloadContribution.entrypoint
-        ],
+        type: "object",
+        required: [NotebookPreloadContribution.type, NotebookPreloadContribution.entrypoint],
         properties: {
             [NotebookPreloadContribution.type]: {
-                type: 'string',
-                description: ( localize(9643, 'Type of the notebook.')),
+                type: "string",
+                description: ( localize(9963, "Type of the notebook."))
             },
             [NotebookPreloadContribution.entrypoint]: {
-                type: 'string',
-                description: ( localize(9644, 'Path to file loaded in the webview.')),
+                type: "string",
+                description: ( localize(9964, "Path to file loaded in the webview."))
             },
             [NotebookPreloadContribution.localResourceRoots]: {
-                type: 'array',
-                items: { type: 'string' },
+                type: "array",
+                items: {
+                    type: "string"
+                },
                 description: ( localize(
-                    9645,
-                    'Paths to additional resources that should be allowed in the webview.'
-                )),
-            },
+                    9965,
+                    "Paths to additional resources that should be allowed in the webview."
+                ))
+            }
         }
     }
 };
 const notebooksExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'notebooks',
+    extensionPoint: "notebooks",
     jsonSchema: notebookProviderContribution,
-    activationEventsGenerator: function* (contribs) {
+    activationEventsGenerator: function*(contribs) {
         for (const contrib of contribs) {
             if (contrib.type) {
                 yield `onNotebookSerializer:${contrib.type}`;
@@ -245,9 +245,9 @@ const notebooksExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     }
 });
 const notebookRendererExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'notebookRenderer',
+    extensionPoint: "notebookRenderer",
     jsonSchema: notebookRendererContribution,
-    activationEventsGenerator: function* (contribs) {
+    activationEventsGenerator: function*(contribs) {
         for (const contrib of contribs) {
             if (contrib.id) {
                 yield `onRenderer:${contrib.id}`;
@@ -256,13 +256,13 @@ const notebookRendererExtensionPoint = ExtensionsRegistry.registerExtensionPoint
     }
 });
 const notebookPreloadExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'notebookPreload',
-    jsonSchema: notebookPreloadContribution,
+    extensionPoint: "notebookPreload",
+    jsonSchema: notebookPreloadContribution
 });
 class NotebooksDataRenderer extends Disposable {
     constructor() {
         super(...arguments);
-        this.type = 'table';
+        this.type = "table";
     }
     shouldRender(manifest) {
         return !!manifest.contributes?.notebooks;
@@ -270,33 +270,31 @@ class NotebooksDataRenderer extends Disposable {
     render(manifest) {
         const contrib = manifest.contributes?.notebooks || [];
         if (!contrib.length) {
-            return { data: { headers: [], rows: [] }, dispose: () => { } };
+            return {
+                data: {
+                    headers: [],
+                    rows: []
+                },
+                dispose: () => {}
+            };
         }
-        const headers = [
-            ( localize(9646, "ID")),
-            ( localize(9647, "Name")),
-        ];
-        const rows = ( contrib
-            .sort((a, b) => a.type.localeCompare(b.type))
-            .map(notebook => {
-            return [
-                notebook.type,
-                notebook.displayName
-            ];
+        const headers = [( localize(9966, "ID")), ( localize(9967, "Name"))];
+        const rows = ( contrib.sort((a, b) => a.type.localeCompare(b.type)).map(notebook => {
+            return [notebook.type, notebook.displayName];
         }));
         return {
             data: {
                 headers,
                 rows
             },
-            dispose: () => { }
+            dispose: () => {}
         };
     }
 }
 class NotebookRenderersDataRenderer extends Disposable {
     constructor() {
         super(...arguments);
-        this.type = 'table';
+        this.type = "table";
     }
     shouldRender(manifest) {
         return !!manifest.contributes?.notebookRenderer;
@@ -304,44 +302,42 @@ class NotebookRenderersDataRenderer extends Disposable {
     render(manifest) {
         const contrib = manifest.contributes?.notebookRenderer || [];
         if (!contrib.length) {
-            return { data: { headers: [], rows: [] }, dispose: () => { } };
+            return {
+                data: {
+                    headers: [],
+                    rows: []
+                },
+                dispose: () => {}
+            };
         }
-        const headers = [
-            ( localize(9648, "Name")),
-            ( localize(9649, "Mimetypes")),
-        ];
-        const rows = ( contrib
-            .sort((a, b) => a.displayName.localeCompare(b.displayName))
-            .map(notebookRenderer => {
-            return [
-                notebookRenderer.displayName,
-                notebookRenderer.mimeTypes.join(',')
-            ];
+        const headers = [( localize(9968, "Name")), ( localize(9969, "Mimetypes"))];
+        const rows = ( contrib.sort((a, b) => a.displayName.localeCompare(b.displayName)).map(notebookRenderer => {
+            return [notebookRenderer.displayName, notebookRenderer.mimeTypes.join(",")];
         }));
         return {
             data: {
                 headers,
                 rows
             },
-            dispose: () => { }
+            dispose: () => {}
         };
     }
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'notebooks',
-    label: ( localize(9650, "Notebooks")),
+    id: "notebooks",
+    label: ( localize(9970, "Notebooks")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(NotebooksDataRenderer)),
+    renderer: ( new SyncDescriptor(NotebooksDataRenderer))
 });
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'notebookRenderer',
-    label: ( localize(9651, "Notebook Renderers")),
+    id: "notebookRenderer",
+    label: ( localize(9971, "Notebook Renderers")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(NotebookRenderersDataRenderer)),
+    renderer: ( new SyncDescriptor(NotebookRenderersDataRenderer))
 });
 
 export { notebookPreloadExtensionPoint, notebookRendererExtensionPoint, notebooksExtensionPoint };