blob: e22c7fd486f2ce90e1119b83f3bae170118bc476 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as glob from 'vs/base/common/glob';
import { Iterable } from 'vs/base/common/iterator';
import { joinPath } from 'vs/base/common/resources';
import { URI } from 'vs/base/common/uri';
import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
import { INotebookRendererInfo, NotebookRendererEntrypoint, NotebookRendererMatch, RendererMessagingSpec } from 'vs/workbench/contrib/notebook/common/notebookCommon';
class DependencyList {
private readonly value: ReadonlySet<string>;
public readonly defined: boolean;
constructor(value: Iterable<string>) {
this.value = new Set(value);
this.defined = this.value.size > 0;
}
public values(): string[] {
return Array.from(this.value);
}
/** Gets whether any of the 'available' dependencies match the ones in this list */
public matches(available: ReadonlyArray<string>) {
// For now this is simple, but this may expand to support globs later
// @see https://github.com/microsoft/vscode/issues/119899
return available.some(v => this.value.has(v));
}
}
export class NotebookOutputRendererInfo implements INotebookRendererInfo {
readonly id: string;
readonly extends?: string;
readonly entrypoint: URI;
readonly displayName: string;
readonly extensionLocation: URI;
readonly extensionId: ExtensionIdentifier;
readonly hardDependencies: DependencyList;
readonly optionalDependencies: DependencyList;
/** @see RendererMessagingSpec */
readonly messaging: RendererMessagingSpec;
// todo: re-add preloads in pure renderer API
readonly preloads: ReadonlyArray<URI> = [];
readonly mimeTypes: readonly string[];
private readonly mimeTypeGlobs: glob.ParsedPattern[];
readonly isBuiltin: boolean;
constructor(descriptor: {
readonly id: string;
readonly displayName: string;
readonly entrypoint: NotebookRendererEntrypoint;
readonly mimeTypes: readonly string[];
readonly extension: IExtensionDescription;
readonly dependencies: readonly string[] | undefined;
readonly optionalDependencies: readonly string[] | undefined;
readonly requiresMessaging: RendererMessagingSpec | undefined;
}) {
this.id = descriptor.id;
this.extensionId = descriptor.extension.identifier;
this.extensionLocation = descriptor.extension.extensionLocation;
this.isBuiltin = descriptor.extension.isBuiltin;
if (typeof descriptor.entrypoint === 'string') {
this.entrypoint = joinPath(this.extensionLocation, descriptor.entrypoint);
} else {
this.extends = descriptor.entrypoint.extends;
this.entrypoint = joinPath(this.extensionLocation, descriptor.entrypoint.path);
}
this.displayName = descriptor.displayName;
this.mimeTypes = descriptor.mimeTypes;
this.mimeTypeGlobs = this.mimeTypes.map(pattern => glob.parse(pattern));
this.hardDependencies = new DependencyList(descriptor.dependencies ?? Iterable.empty());
this.optionalDependencies = new DependencyList(descriptor.optionalDependencies ?? Iterable.empty());
this.messaging = descriptor.requiresMessaging ?? RendererMessagingSpec.Never;
}
public get dependencies(): string[] {
return this.hardDependencies.values();
}
public matchesWithoutKernel(mimeType: string) {
if (!this.matchesMimeTypeOnly(mimeType)) {
return NotebookRendererMatch.Never;
}
if (this.hardDependencies.defined) {
return NotebookRendererMatch.WithHardKernelDependency;
}
if (this.optionalDependencies.defined) {
return NotebookRendererMatch.WithOptionalKernelDependency;
}
return NotebookRendererMatch.Pure;
}
public matches(mimeType: string, kernelProvides: ReadonlyArray<string>) {
if (!this.matchesMimeTypeOnly(mimeType)) {
return NotebookRendererMatch.Never;
}
if (this.hardDependencies.defined) {
return this.hardDependencies.matches(kernelProvides)
? NotebookRendererMatch.WithHardKernelDependency
: NotebookRendererMatch.Never;
}
return this.optionalDependencies.matches(kernelProvides)
? NotebookRendererMatch.WithOptionalKernelDependency
: NotebookRendererMatch.Pure;
}
private matchesMimeTypeOnly(mimeType: string) {
if (this.extends !== undefined) {
return false;
}
return this.mimeTypeGlobs.some(pattern => pattern(mimeType)) || this.mimeTypes.some(pattern => pattern === mimeType);
}
}
|
