@codingame/monaco-vscode-api 1.67.14 → 1.67.15

package/dist/{services-621e567e.js → services-7a462d46.js}

@@ -13,6 +13,7 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { raceCancellation, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
@@ -269,6 +270,60 @@ function isValidBasename(name, isWindowsOS = isWindows) {
     }
     return true;
 }
+function sortedDiff(before, after, compare) {
+    const result = [];
+    function pushSplice(start, deleteCount, toInsert) {
+        if (deleteCount === 0 && toInsert.length === 0) {
+            return;
+        }
+        const latest = result[result.length - 1];
+        if (latest && latest.start + latest.deleteCount === start) {
+            latest.deleteCount += deleteCount;
+            latest.toInsert.push(...toInsert);
+        }
+        else {
+            result.push({ start, deleteCount, toInsert });
+        }
+    }
+    let beforeIdx = 0;
+    let afterIdx = 0;
+    while (true) {
+        if (beforeIdx === before.length) {
+            pushSplice(beforeIdx, 0, after.slice(afterIdx));
+            break;
+        }
+        if (afterIdx === after.length) {
+            pushSplice(beforeIdx, before.length - beforeIdx, []);
+            break;
+        }
+        const beforeElement = before[beforeIdx];
+        const afterElement = after[afterIdx];
+        const n = compare(beforeElement, afterElement);
+        if (n === 0) {
+            beforeIdx += 1;
+            afterIdx += 1;
+        }
+        else if (n < 0) {
+            pushSplice(beforeIdx, 1, []);
+            beforeIdx += 1;
+        }
+        else if (n > 0) {
+            pushSplice(beforeIdx, 0, [afterElement]);
+            afterIdx += 1;
+        }
+    }
+    return result;
+}
+function delta(before, after, compare) {
+    const splices = sortedDiff(before, after, compare);
+    const removed = [];
+    const added = [];
+    for (const splice of splices) {
+        removed.push(...before.slice(splice.start, splice.start + splice.deleteCount));
+        added.push(...splice.toInsert);
+    }
+    return { removed, added };
+}
 function coalesceInPlace(array) {
     let to = 0;
     for (let i = 0; i < array.length; i++) {
@@ -291,6 +346,11 @@ function remove(array, element) {
     }
     return undefined;
 }
+function mapArrayOrNot(items, fn) {
+    return Array.isArray(items) ?
+        items.map(fn) :
+        fn(items);
+}
 var NeverShowAgainScope;
  (function(NeverShowAgainScope) {
     NeverShowAgainScope[NeverShowAgainScope["WORKSPACE"] = 0] = "WORKSPACE";
@@ -351,6 +411,24 @@ var FilePermission;
  (function(FilePermission) {
     FilePermission[FilePermission["Readonly"] = 1] = "Readonly";
 })(FilePermission || (FilePermission = {}));
+function hasReadWriteCapability(provider) {
+    return !!((provider.capabilities & 2) );
+}
+function hasFileFolderCopyCapability(provider) {
+    return !!((provider.capabilities & 8) );
+}
+function hasOpenReadWriteCloseCapability(provider) {
+    return !!((provider.capabilities & 4) );
+}
+function hasFileReadStreamCapability(provider) {
+    return !!((provider.capabilities & 16) );
+}
+function hasFileAtomicReadCapability(provider) {
+    if (!hasReadWriteCapability(provider)) {
+        return false;
+    }
+    return !!((provider.capabilities & 16384) );
+}
 var FileSystemProviderErrorCode;
  (function(FileSystemProviderErrorCode) {
     FileSystemProviderErrorCode["FileExists"] = "EntryExists";
@@ -364,10 +442,181 @@ var FileSystemProviderErrorCode;
     FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
     FileSystemProviderErrorCode["Unknown"] = "Unknown";
 })(FileSystemProviderErrorCode || (FileSystemProviderErrorCode = {}));
+class FileSystemProviderError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+function createFileSystemProviderError(error, code) {
+    const providerError =  new FileSystemProviderError(error.toString(), code);
+    markAsFileSystemProviderError(providerError, code);
+    return providerError;
+}
+function ensureFileSystemProviderError(error) {
+    if (!error) {
+        return createFileSystemProviderError( localize('unknownError', "Unknown Error"), FileSystemProviderErrorCode.Unknown);
+    }
+    return error;
+}
 function markAsFileSystemProviderError(error, code) {
     error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;
     return error;
 }
+function toFileSystemProviderErrorCode(error) {
+    if (!error) {
+        return FileSystemProviderErrorCode.Unknown;
+    }
+    if (error instanceof FileSystemProviderError) {
+        return error.code;
+    }
+    const match = /^(.+) \(FileSystemError\)$/.exec(error.name);
+    if (!match) {
+        return FileSystemProviderErrorCode.Unknown;
+    }
+    switch (match[1]) {
+        case FileSystemProviderErrorCode.FileExists: return FileSystemProviderErrorCode.FileExists;
+        case FileSystemProviderErrorCode.FileIsADirectory: return FileSystemProviderErrorCode.FileIsADirectory;
+        case FileSystemProviderErrorCode.FileNotADirectory: return FileSystemProviderErrorCode.FileNotADirectory;
+        case FileSystemProviderErrorCode.FileNotFound: return FileSystemProviderErrorCode.FileNotFound;
+        case FileSystemProviderErrorCode.FileExceedsMemoryLimit: return FileSystemProviderErrorCode.FileExceedsMemoryLimit;
+        case FileSystemProviderErrorCode.FileTooLarge: return FileSystemProviderErrorCode.FileTooLarge;
+        case FileSystemProviderErrorCode.FileWriteLocked: return FileSystemProviderErrorCode.FileWriteLocked;
+        case FileSystemProviderErrorCode.NoPermissions: return FileSystemProviderErrorCode.NoPermissions;
+        case FileSystemProviderErrorCode.Unavailable: return FileSystemProviderErrorCode.Unavailable;
+    }
+    return FileSystemProviderErrorCode.Unknown;
+}
+function toFileOperationResult(error) {
+    if (error instanceof FileOperationError) {
+        return error.fileOperationResult;
+    }
+    switch (toFileSystemProviderErrorCode(error)) {
+        case FileSystemProviderErrorCode.FileNotFound:
+            return 1 ;
+        case FileSystemProviderErrorCode.FileIsADirectory:
+            return 0 ;
+        case FileSystemProviderErrorCode.FileNotADirectory:
+            return 10 ;
+        case FileSystemProviderErrorCode.FileWriteLocked:
+            return 5 ;
+        case FileSystemProviderErrorCode.NoPermissions:
+            return 6 ;
+        case FileSystemProviderErrorCode.FileExists:
+            return 4 ;
+        case FileSystemProviderErrorCode.FileExceedsMemoryLimit:
+            return 9 ;
+        case FileSystemProviderErrorCode.FileTooLarge:
+            return 7 ;
+        default:
+            return 11 ;
+    }
+}
+class FileOperationEvent {
+    constructor(resource, operation, target) {
+        this.resource = resource;
+        this.operation = operation;
+        this.target = target;
+    }
+    isOperation(operation) {
+        return this.operation === operation;
+    }
+}
+class FileChangesEvent {
+    constructor(changes, ignorePathCasing) {
+        this.added = undefined;
+        this.updated = undefined;
+        this.deleted = undefined;
+        this.rawChanges = [];
+        this.rawAdded = [];
+        this.rawUpdated = [];
+        this.rawDeleted = [];
+        this.rawChanges = changes;
+        const entriesByType =  new Map();
+        for (const change of changes) {
+            const array = entriesByType.get(change.type);
+            if (array) {
+                array.push([change.resource, change]);
+            }
+            else {
+                entriesByType.set(change.type, [[change.resource, change]]);
+            }
+            switch (change.type) {
+                case 1 :
+                    this.rawAdded.push(change.resource);
+                    break;
+                case 0 :
+                    this.rawUpdated.push(change.resource);
+                    break;
+                case 2 :
+                    this.rawDeleted.push(change.resource);
+                    break;
+            }
+        }
+        for (const [key, value] of entriesByType) {
+            switch (key) {
+                case 1 :
+                    this.added = TernarySearchTree.forUris(() => ignorePathCasing);
+                    this.added.fill(value);
+                    break;
+                case 0 :
+                    this.updated = TernarySearchTree.forUris(() => ignorePathCasing);
+                    this.updated.fill(value);
+                    break;
+                case 2 :
+                    this.deleted = TernarySearchTree.forUris(() => ignorePathCasing);
+                    this.deleted.fill(value);
+                    break;
+            }
+        }
+    }
+    contains(resource, ...types) {
+        return this.doContains(resource, { includeChildren: false }, ...types);
+    }
+    affects(resource, ...types) {
+        return this.doContains(resource, { includeChildren: true }, ...types);
+    }
+    doContains(resource, options, ...types) {
+        if (!resource) {
+            return false;
+        }
+        const hasTypesFilter = types.length > 0;
+        if (!hasTypesFilter || types.includes(1 )) {
+            if (this.added?.get(resource)) {
+                return true;
+            }
+            if (options.includeChildren && this.added?.findSuperstr(resource)) {
+                return true;
+            }
+        }
+        if (!hasTypesFilter || types.includes(0 )) {
+            if (this.updated?.get(resource)) {
+                return true;
+            }
+            if (options.includeChildren && this.updated?.findSuperstr(resource)) {
+                return true;
+            }
+        }
+        if (!hasTypesFilter || types.includes(2 )) {
+            if (this.deleted?.findSubstr(resource) ) {
+                return true;
+            }
+            if (options.includeChildren && this.deleted?.findSuperstr(resource)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    gotAdded() {
+        return !!this.added;
+    }
+    gotDeleted() {
+        return !!this.deleted;
+    }
+    gotUpdated() {
+        return !!this.updated;
+    }
+}
 class FileOperationError extends ErrorNoTelemetry {
     constructor(message, fileOperationResult, options) {
         super(message);
@@ -375,6 +624,19 @@ class FileOperationError extends ErrorNoTelemetry {
         this.options = options;
     }
 }
+class NotModifiedSinceFileOperationError extends FileOperationError {
+    constructor(message, stat, options) {
+        super(message, 2 , options);
+        this.stat = stat;
+    }
+}
+const ETAG_DISABLED = '';
+function etag(stat) {
+    if (typeof stat.size !== 'number' || typeof stat.mtime !== 'number') {
+        return undefined;
+    }
+    return stat.mtime.toString(29) + stat.size.toString(31);
+}
 const IEditorGroupsService =  createDecorator('editorGroupsService');
 function isEditorGroup(obj) {
     const group = obj;
@@ -770,4 +1032,4 @@ var Services;
     }
     Services.install = install;
 })(Services || (Services = {}));
-export { ACTIVE_GROUP as A, CancellationTokenSource as C, FileSystemProviderErrorCode as F, IProgressService as I, NoOpNotification as N, SIDE_GROUP as S, __classPrivateFieldSet as _, __classPrivateFieldGet as a, __decorate as b, coalesceInPlace as c, __param as d, ITextFileService as e, IFileService as f, IWorkbenchEnvironmentService as g, IUriIdentityService as h, IWorkingCopyFileService as i, IPathService as j, disposed as k, IEditorService as l, markAsFileSystemProviderError as m, IEditorGroupsService as n, IPaneCompositePartService as o, IProductService as p, ILanguageStatusService as q, readonly as r, IHostService as s, Services as t, FileType as u, FilePermission as v, NotificationsFilter as w, refineServiceDecorator as x, NeverShowAgainScope as y, isPreferredGroup as z };
+export { ACTIVE_GROUP as A, NeverShowAgainScope as B, CancellationTokenSource as C, isPreferredGroup as D, ensureFileSystemProviderError as E, FileSystemProviderErrorCode as F, createFileSystemProviderError as G, FileChangesEvent as H, IProgressService as I, FileOperationError as J, hasOpenReadWriteCloseCapability as K, hasReadWriteCapability as L, hasFileReadStreamCapability as M, NoOpNotification as N, toFileSystemProviderErrorCode as O, etag as P, FileOperationEvent as Q, toFileOperationResult as R, SIDE_GROUP as S, ETAG_DISABLED as T, hasFileAtomicReadCapability as U, NotModifiedSinceFileOperationError as V, hasFileFolderCopyCapability as W, __classPrivateFieldSet as _, __classPrivateFieldGet as a, __decorate as b, coalesceInPlace as c, __param as d, delta as e, mapArrayOrNot as f, ITextFileService as g, IFileService as h, IWorkbenchEnvironmentService as i, IUriIdentityService as j, IWorkingCopyFileService as k, IPathService as l, markAsFileSystemProviderError as m, disposed as n, IEditorService as o, IEditorGroupsService as p, IPaneCompositePartService as q, readonly as r, IProductService as s, ILanguageStatusService as t, IHostService as u, Services as v, FileType as w, FilePermission as x, NotificationsFilter as y, refineServiceDecorator as z };