@codingame/monaco-vscode-2f06fe84-148e-5e6b-a7ca-c7989c5f128a-common 15.0.3 → 16.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@codingame/monaco-vscode-2f06fe84-148e-5e6b-a7ca-c7989c5f128a-common",
3
- "version": "15.0.3",
3
+ "version": "16.0.0",
4
4
  "private": false,
5
5
  "description": "VSCode public API plugged on the monaco editor - common package (files, storage, user-data-profile)",
6
6
  "keywords": [],
@@ -15,13 +15,16 @@
15
15
  },
16
16
  "type": "module",
17
17
  "dependencies": {
18
- "@codingame/monaco-vscode-81f603ca-d6ea-5402-90dd-3014dffc63b4-common": "15.0.3",
19
- "@codingame/monaco-vscode-api": "15.0.3"
18
+ "@codingame/monaco-vscode-api": "16.0.0",
19
+ "@codingame/monaco-vscode-b1110435-a331-5549-ab1e-aa3d763c3a1f-common": "16.0.0"
20
20
  },
21
21
  "exports": {
22
22
  ".": {
23
23
  "default": "./empty.js"
24
24
  },
25
+ "./vscode/*.css": {
26
+ "default": "./vscode/src/*.css"
27
+ },
25
28
  "./vscode/*": {
26
29
  "types": "./vscode/src/*.d.ts",
27
30
  "default": "./vscode/src/*.js"
@@ -1,6 +1,6 @@
1
1
 
2
2
  import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
3
- import { BroadcastDataChannel } from '@codingame/monaco-vscode-81f603ca-d6ea-5402-90dd-3014dffc63b4-common/vscode/vs/base/browser/broadcast';
3
+ import { BroadcastDataChannel } from '@codingame/monaco-vscode-b1110435-a331-5549-ab1e-aa3d763c3a1f-common/vscode/vs/base/browser/broadcast';
4
4
  import { isSafari } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/browser';
5
5
  import { getActiveWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
6
6
  import { IndexedDB } from '../../../../base/browser/indexedDB.js';
@@ -29,9 +29,9 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
29
29
  this.userDataProfileService = userDataProfileService;
30
30
  this.logService = logService;
31
31
  this.applicationStoragePromise = ( new DeferredPromise());
32
- this.profileStorageProfile = this.userDataProfileService.currentProfile;
33
32
  this.profileStorageDisposables = this._register(( new DisposableStore()));
34
33
  this.workspaceStorageDisposables = this._register(( new DisposableStore()));
34
+ this.profileStorageProfile = this.userDataProfileService.currentProfile;
35
35
  this.registerListeners();
36
36
  }
37
37
  registerListeners() {
@@ -1,60 +0,0 @@
1
- import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
2
- import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
3
- import { ReadableStreamEvents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
4
- import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
5
- import { IFileDeleteOptions, IFileOverwriteOptions, FileSystemProviderCapabilities, FileType, IFileWriteOptions, IFileChange, IFileSystemProviderWithFileReadWriteCapability, IStat, IWatchOptions, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileOpenOptions, IFileSystemProviderWithFileAtomicDeleteCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileReadStreamCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
6
- declare class File implements IStat {
7
- readonly type: FileType.File;
8
- readonly ctime: number;
9
- mtime: number;
10
- size: number;
11
- name: string;
12
- data?: Uint8Array;
13
- constructor(name: string);
14
- }
15
- declare class Directory implements IStat {
16
- readonly type: FileType.Directory;
17
- readonly ctime: number;
18
- mtime: number;
19
- size: number;
20
- name: string;
21
- readonly entries: Map<string, File | Directory>;
22
- constructor(name: string);
23
- }
24
- export declare class InMemoryFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability {
25
- private memoryFdCounter;
26
- private readonly fdMemory;
27
- private _onDidChangeCapabilities;
28
- readonly onDidChangeCapabilities: Event<void>;
29
- private _capabilities;
30
- get capabilities(): FileSystemProviderCapabilities;
31
- setReadOnly(readonly: boolean): void;
32
- root: Directory;
33
- stat(resource: URI): Promise<IStat>;
34
- readdir(resource: URI): Promise<[
35
- string,
36
- FileType
37
- ][]>;
38
- readFile(resource: URI): Promise<Uint8Array>;
39
- readFileStream(resource: URI): ReadableStreamEvents<Uint8Array>;
40
- writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
41
- open(resource: URI, opts: IFileOpenOptions): Promise<number>;
42
- close(fd: number): Promise<void>;
43
- read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
44
- write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
45
- rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
46
- delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
47
- mkdir(resource: URI): Promise<void>;
48
- private _lookup;
49
- private _lookupAsDirectory;
50
- private _lookupAsFile;
51
- private _lookupParentDirectory;
52
- private readonly _onDidChangeFile;
53
- readonly onDidChangeFile: Event<readonly IFileChange[]>;
54
- private _bufferedChanges;
55
- private _fireSoonHandle?;
56
- watch(resource: URI, opts: IWatchOptions): IDisposable;
57
- private _fireSoon;
58
- dispose(): void;
59
- }
60
- export {};
@@ -1,223 +0,0 @@
1
-
2
- import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
3
- import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
4
- import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
5
- import { basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
6
- import { newWriteableStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stream';
7
- import { FileType, FileSystemProviderCapabilities, createFileSystemProviderError, FileSystemProviderErrorCode, FileChangeType } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
8
-
9
- class File {
10
- constructor(name) {
11
- this.type = FileType.File;
12
- this.ctime = Date.now();
13
- this.mtime = Date.now();
14
- this.size = 0;
15
- this.name = name;
16
- }
17
- }
18
- class Directory {
19
- constructor(name) {
20
- this.type = FileType.Directory;
21
- this.ctime = Date.now();
22
- this.mtime = Date.now();
23
- this.size = 0;
24
- this.name = name;
25
- this.entries = ( new Map());
26
- }
27
- }
28
- class InMemoryFileSystemProvider extends Disposable {
29
- constructor() {
30
- super(...arguments);
31
- this.memoryFdCounter = 0;
32
- this.fdMemory = ( new Map());
33
- this._onDidChangeCapabilities = this._register(( new Emitter()));
34
- this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
35
- this._capabilities = FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive;
36
- this.root = ( new Directory(''));
37
- this._onDidChangeFile = this._register(( new Emitter()));
38
- this.onDidChangeFile = this._onDidChangeFile.event;
39
- this._bufferedChanges = [];
40
- }
41
- get capabilities() { return this._capabilities; }
42
- setReadOnly(readonly) {
43
- const isReadonly = !!(this._capabilities & FileSystemProviderCapabilities.Readonly);
44
- if (readonly !== isReadonly) {
45
- this._capabilities = readonly ? FileSystemProviderCapabilities.Readonly | FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileReadWrite
46
- : FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive;
47
- this._onDidChangeCapabilities.fire();
48
- }
49
- }
50
- async stat(resource) {
51
- return this._lookup(resource, false);
52
- }
53
- async readdir(resource) {
54
- const entry = this._lookupAsDirectory(resource, false);
55
- const result = [];
56
- entry.entries.forEach((child, name) => result.push([name, child.type]));
57
- return result;
58
- }
59
- async readFile(resource) {
60
- const data = this._lookupAsFile(resource, false).data;
61
- if (data) {
62
- return data;
63
- }
64
- throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
65
- }
66
- readFileStream(resource) {
67
- const data = this._lookupAsFile(resource, false).data;
68
- const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
69
- stream.end(data);
70
- return stream;
71
- }
72
- async writeFile(resource, content, opts) {
73
- const basename$1 = basename(resource);
74
- const parent = this._lookupParentDirectory(resource);
75
- let entry = parent.entries.get(basename$1);
76
- if (entry instanceof Directory) {
77
- throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
78
- }
79
- if (!entry && !opts.create) {
80
- throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
81
- }
82
- if (entry && opts.create && !opts.overwrite) {
83
- throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
84
- }
85
- if (!entry) {
86
- entry = ( new File(basename$1));
87
- parent.entries.set(basename$1, entry);
88
- this._fireSoon({ type: FileChangeType.ADDED, resource });
89
- }
90
- entry.mtime = Date.now();
91
- entry.size = content.byteLength;
92
- entry.data = content;
93
- this._fireSoon({ type: FileChangeType.UPDATED, resource });
94
- }
95
- open(resource, opts) {
96
- const data = this._lookupAsFile(resource, false).data;
97
- if (data) {
98
- const fd = this.memoryFdCounter++;
99
- this.fdMemory.set(fd, data);
100
- return Promise.resolve(fd);
101
- }
102
- throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
103
- }
104
- close(fd) {
105
- this.fdMemory.delete(fd);
106
- return Promise.resolve();
107
- }
108
- read(fd, pos, data, offset, length) {
109
- const memory = this.fdMemory.get(fd);
110
- if (!memory) {
111
- throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
112
- }
113
- const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
114
- data.set(toWrite.buffer, offset);
115
- return Promise.resolve(toWrite.byteLength);
116
- }
117
- write(fd, pos, data, offset, length) {
118
- const memory = this.fdMemory.get(fd);
119
- if (!memory) {
120
- throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
121
- }
122
- const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
123
- memory.set(toWrite.buffer, pos);
124
- return Promise.resolve(toWrite.byteLength);
125
- }
126
- async rename(from, to, opts) {
127
- if (!opts.overwrite && this._lookup(to, true)) {
128
- throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
129
- }
130
- const entry = this._lookup(from, false);
131
- const oldParent = this._lookupParentDirectory(from);
132
- const newParent = this._lookupParentDirectory(to);
133
- const newName = basename(to);
134
- oldParent.entries.delete(entry.name);
135
- entry.name = newName;
136
- newParent.entries.set(newName, entry);
137
- this._fireSoon({ type: FileChangeType.DELETED, resource: from }, { type: FileChangeType.ADDED, resource: to });
138
- }
139
- async delete(resource, opts) {
140
- const dirname$1 = dirname(resource);
141
- const basename$1 = basename(resource);
142
- const parent = this._lookupAsDirectory(dirname$1, false);
143
- if (( parent.entries.has(basename$1))) {
144
- parent.entries.delete(basename$1);
145
- parent.mtime = Date.now();
146
- parent.size -= 1;
147
- this._fireSoon({ type: FileChangeType.UPDATED, resource: dirname$1 }, { resource, type: FileChangeType.DELETED });
148
- }
149
- }
150
- async mkdir(resource) {
151
- if (this._lookup(resource, true)) {
152
- throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
153
- }
154
- const basename$1 = basename(resource);
155
- const dirname$1 = dirname(resource);
156
- const parent = this._lookupAsDirectory(dirname$1, false);
157
- const entry = ( new Directory(basename$1));
158
- parent.entries.set(entry.name, entry);
159
- parent.mtime = Date.now();
160
- parent.size += 1;
161
- this._fireSoon({ type: FileChangeType.UPDATED, resource: dirname$1 }, { type: FileChangeType.ADDED, resource });
162
- }
163
- _lookup(uri, silent) {
164
- const parts = uri.path.split('/');
165
- let entry = this.root;
166
- for (const part of parts) {
167
- if (!part) {
168
- continue;
169
- }
170
- let child;
171
- if (entry instanceof Directory) {
172
- child = entry.entries.get(part);
173
- }
174
- if (!child) {
175
- if (!silent) {
176
- throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
177
- }
178
- else {
179
- return undefined;
180
- }
181
- }
182
- entry = child;
183
- }
184
- return entry;
185
- }
186
- _lookupAsDirectory(uri, silent) {
187
- const entry = this._lookup(uri, silent);
188
- if (entry instanceof Directory) {
189
- return entry;
190
- }
191
- throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
192
- }
193
- _lookupAsFile(uri, silent) {
194
- const entry = this._lookup(uri, silent);
195
- if (entry instanceof File) {
196
- return entry;
197
- }
198
- throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
199
- }
200
- _lookupParentDirectory(uri) {
201
- const dirname$1 = dirname(uri);
202
- return this._lookupAsDirectory(dirname$1, false);
203
- }
204
- watch(resource, opts) {
205
- return Disposable.None;
206
- }
207
- _fireSoon(...changes) {
208
- this._bufferedChanges.push(...changes);
209
- if (this._fireSoonHandle) {
210
- clearTimeout(this._fireSoonHandle);
211
- }
212
- this._fireSoonHandle = setTimeout(() => {
213
- this._onDidChangeFile.fire(this._bufferedChanges);
214
- this._bufferedChanges.length = 0;
215
- }, 5);
216
- }
217
- dispose() {
218
- super.dispose();
219
- this.fdMemory.clear();
220
- }
221
- }
222
-
223
- export { InMemoryFileSystemProvider };