@codingame/monaco-vscode-files-service-override 1.82.4 → 1.82.5-next.0

package/files.d.ts

@@ -0,0 +1,101 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { FileType, IStat, IFileSystemProviderWithFileReadWriteCapability, IFileChange, IFileSystemProvider, FileSystemProviderCapabilities, FileChangeType, IFileWriteOptions, IWatchOptions, IFileDeleteOptions, IFileOverwriteOptions } from 'vscode/vscode/vs/platform/files/common/files';
+export { FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions } from 'vscode/vscode/vs/platform/files/common/files';
+
+declare abstract class RegisteredFile {
+    uri: URI;
+    private readonly;
+    private ctime;
+    private mtime;
+    readonly type: FileType;
+    protected _onDidChange: Emitter<void>;
+    onDidChange: Event<void>;
+    protected _onDidDelete: Emitter<void>;
+    onDidDelete: Event<void>;
+    protected _onDidRename: Emitter<{
+        from: URI;
+        to: URI;
+    }>;
+    onDidRename: Event<{
+        from: URI;
+        to: URI;
+    }>;
+    constructor(uri: URI, readonly: boolean);
+    stats(): Promise<IStat>;
+    getSize(): Promise<number>;
+    abstract read(): Promise<string | Uint8Array>;
+    abstract write(content: string): Promise<void>;
+    delete(): Promise<void>;
+    rename(to: URI): Promise<void>;
+}
+declare class RegisteredReadOnlyFile extends RegisteredFile {
+    read: () => Promise<string | Uint8Array>;
+    constructor(uri: URI, read: () => Promise<string | Uint8Array>);
+    write(): Promise<void>;
+    delete(): Promise<void>;
+    rename(): Promise<void>;
+}
+declare class RegisteredMemoryFile extends RegisteredFile {
+    private content;
+    constructor(uri: URI, content: string);
+    read(): Promise<string | Uint8Array>;
+    write(content: string): Promise<void>;
+}
+declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+    private files;
+    capabilities: number;
+    constructor(readonly: boolean);
+    onDidChangeCapabilities: Event<any>;
+    _onDidChangeFile: Emitter<readonly IFileChange[]>;
+    onDidChangeFile: Event<readonly IFileChange[]>;
+    registerFile(file: RegisteredFile): IDisposable;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    watch(): IDisposable;
+    writeFile(resource: URI, content: Uint8Array): Promise<void>;
+    delete(resource: URI): Promise<void>;
+    rename(from: URI, to: URI): Promise<void>;
+    mkdir(): Promise<never>;
+}
+declare class DelegateFileSystemProvider implements IFileSystemProvider {
+    private options;
+    constructor(options: {
+        delegate: IFileSystemProvider;
+        toDelegate: (uri: URI) => URI;
+        fromDeletate: (uri: URI) => URI;
+    });
+    get capabilities(): FileSystemProviderCapabilities;
+    onDidChangeCapabilities: Event<void>;
+    onDidChangeFile: Event<{
+        type: FileChangeType;
+        resource: URI;
+    }[]>;
+    readFile: ((resource: URI) => Promise<Uint8Array>) | undefined;
+    writeFile: ((resource: URI, content: Uint8Array, opts: IFileWriteOptions) => Promise<void>) | undefined;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    stat(resource: URI): Promise<IStat>;
+    mkdir(resource: URI): Promise<void>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+}
+declare function getServiceOverride(): IEditorOverrideServices;
+declare function registerExtensionFile(extensionLocation: URI, filePath: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
+/**
+ * Register a file system overlay
+ *
+ * By default, a memory filesystem is used to read and write file
+ *
+ * This method allows to register another fileSystemProvider in front OR behind the default memory one.
+ *
+ * The default one is registered as priority: 0, so:
+ * - any provider registered with a positive priority will be in front of the default one
+ * - any provider registered with a negative priority will be behind the default one
+ */
+declare function registerFileSystemOverlay(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
+
+export { DelegateFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/index.d.ts

@@ -1,2 +1,4 @@
-export { default } from 'vscode/service-override/files'
-export * from 'vscode/service-override/files'
+export { DelegateFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, default, registerExtensionFile, registerFileSystemOverlay } from './files.js';
+export { InMemoryFileSystemProvider } from './vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js';
+export { FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions } from 'vscode/vscode/vs/platform/files/common/files';
+export { HTMLFileSystemProvider } from './vscode/src/vs/platform/files/browser/htmlFileSystemProvider.js';

package/index.js

@@ -1,2 +1,2 @@
-export { default } from 'vscode/service-override/files'
-export * from 'vscode/service-override/files'
+export * from 'vscode/service-override/files';
+export { default } from 'vscode/service-override/files';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-files-service-override",
-  "version": "1.82.4",
+  "version": "1.82.5-next.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.4",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.82.5-next.0",
     "monaco-editor": "0.43.0"
   }
 }

package/vscode/src/vs/base/browser/indexedDB.d.ts

@@ -0,0 +1,17 @@
+declare class IndexedDB {
+    private readonly name;
+    static create(name: string, version: number | undefined, stores: string[]): Promise<IndexedDB>;
+    private static openDatabase;
+    private static doOpenDatabase;
+    private static deleteDatabase;
+    private database;
+    private readonly pendingTransactions;
+    constructor(database: IDBDatabase, name: string);
+    hasPendingTransactions(): boolean;
+    close(): void;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>[]): Promise<T[]>;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T>;
+    getKeyValues<V>(store: string, isValid: (value: unknown) => value is V): Promise<Map<string, V>>;
+}
+
+export { IndexedDB };

package/vscode/src/vs/platform/files/browser/htmlFileSystemProvider.d.ts

@@ -0,0 +1,43 @@
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ReadableStreamEvents } from 'vscode/vscode/vs/base/common/stream';
+import { IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability, FileSystemProviderCapabilities, IStat, FileType, IFileReadStreamOptions, IFileWriteOptions, IFileDeleteOptions, IFileOverwriteOptions, IWatchOptions } from 'vscode/vscode/vs/platform/files/common/files';
+import { IndexedDB } from '../../../base/browser/indexedDB.js';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+
+declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability {
+    private indexedDB;
+    private readonly store;
+    private logService;
+    readonly onDidChangeCapabilities: Event<any>;
+    readonly onDidChangeFile: Event<any>;
+    private extUri;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    constructor(indexedDB: IndexedDB | undefined, store: string, logService: ILogService);
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    private readonly _files;
+    private readonly _directories;
+    registerFileHandle(handle: FileSystemFileHandle): Promise<URI>;
+    registerDirectoryHandle(handle: FileSystemDirectoryHandle): Promise<URI>;
+    get directories(): Iterable<FileSystemDirectoryHandle>;
+    private registerHandle;
+    getHandle(resource: URI): Promise<FileSystemHandle | undefined>;
+    private getFileHandle;
+    private getDirectoryHandle;
+    private doGetHandle;
+    private toFileSystemProviderError;
+    private createFileSystemProviderError;
+}
+
+export { HTMLFileSystemProvider };

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.d.ts

@@ -0,0 +1,50 @@
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IFileSystemProviderWithFileReadWriteCapability, FileSystemProviderCapabilities, IStat, FileType, IFileWriteOptions, IFileOverwriteOptions, IFileDeleteOptions, IFileChange, IWatchOptions } from 'vscode/vscode/vs/platform/files/common/files';
+
+declare class File implements IStat {
+    type: FileType.File;
+    ctime: number;
+    mtime: number;
+    size: number;
+    name: string;
+    data?: Uint8Array;
+    constructor(name: string);
+}
+declare class Directory implements IStat {
+    type: FileType.Directory;
+    ctime: number;
+    mtime: number;
+    size: number;
+    name: string;
+    entries: Map<string, File | Directory>;
+    constructor(name: string);
+}
+declare class InMemoryFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+    private _onDidChangeCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    setReadOnly(readonly: boolean): void;
+    root: Directory;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
+    private _lookup;
+    private _lookupAsDirectory;
+    private _lookupAsFile;
+    private _lookupParentDirectory;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    private _bufferedChanges;
+    private _fireSoonHandle?;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    private _fireSoon;
+}
+
+export { InMemoryFileSystemProvider };