@lvce-editor/api 8.81.0 → 8.83.0

package/dist/parts/FileSystemProviderRegistry/FileSystemProviderRegistry.d.ts

@@ -9,6 +9,7 @@ export declare const executeFileSystemProviderRename: (id: string, oldUri: strin
 export declare const executeFileSystemProviderWriteFile: (id: string, uri: string, content: string) => Promise<void>;
 export declare const executeFileSystemProviderReadDirWithFileTypes: (id: string, uri: string) => Promise<readonly FileSystemDirent[]>;
 export declare const executeFileSystemProviderGetPathSeparator: (id: string) => string;
+export declare const getFileSystemProviderPathSeparator: (id: string) => string | undefined;
 export declare const executeFileSystemProviderIsReadonly: (id: string) => Promise<boolean>;
 export declare const getFileSystemProviderRegistrySnapshot: () => FileSystemProviderRegistrySnapshot;
 export declare const registerFileSystemProvider: (provider: FileSystemProvider) => Disposable;

package/dist/parts/FileSystemProviderRegistry/FileSystemProviderRegistry.js

@@ -77,6 +77,13 @@ export const executeFileSystemProviderReadDirWithFileTypes = async (id, uri) =>
 export const executeFileSystemProviderGetPathSeparator = (id) => {
     return getProvider(id).pathSeparator || '/';
 };
+export const getFileSystemProviderPathSeparator = (id) => {
+    const provider = providers[id];
+    if (!provider) {
+        return undefined;
+    }
+    return provider.pathSeparator || '/';
+};
 export const executeFileSystemProviderIsReadonly = async (id) => {
     const provider = getProvider(id);
     return provider.isReadonly ? provider.isReadonly() : false;

package/dist/parts/Host/Host.js

@@ -1,4 +1,5 @@
 import { executeCommand } from "../ExecuteCommand/ExecuteCommand.js";
+import { getFileSystemProviderPathSeparator } from "../FileSystemProviderRegistry/FileSystemProviderRegistry.js";
 export const confirm = async (message) => {
     return Boolean(await executeCommand('ConfirmPrompt.prompt', message));
 };
@@ -18,5 +19,12 @@ export const showNotification = async (type, message) => {
     await executeCommand('Notification.create', type, message);
 };
 export const setWorkspaceUri = async (uri) => {
-    await executeCommand('Workspace.setUri', uri);
+    const protocolEnd = uri.indexOf(':');
+    const protocol = protocolEnd === -1 ? '' : uri.slice(0, protocolEnd);
+    const pathSeparator = getFileSystemProviderPathSeparator(protocol);
+    if (pathSeparator === undefined) {
+        await executeCommand('Workspace.setUri', uri);
+        return;
+    }
+    await executeCommand('Workspace.setUri', uri, pathSeparator);
 };

package/dist/parts/OutputChannel/OutputChannel.d.ts

@@ -3,8 +3,8 @@ import type { OutputChannelRegistrySnapshot } from '../OutputChannelRegistrySnap
 export declare const activateOutputChannels: () => void;
 export declare const createOutputChannel: (id: string) => OutputChannel;
 export declare const getOutputChannelRegistrySnapshot: () => OutputChannelRegistrySnapshot;
-export declare const getOutputChannelLogs: (id: string) => string | undefined;
-export declare const clearOutputChannel: (id: string) => boolean;
+export declare const getOutputChannelLogs: (id: string) => Promise<string | undefined>;
+export declare const clearOutputChannel: (id: string) => Promise<boolean>;
 export declare const resetOutputChannelRegistry: () => void;
 export type { OutputChannel } from '../OutputChannelHandle/OutputChannelHandle.ts';
 export type { OutputChannelRegistrySnapshot } from '../OutputChannelRegistrySnapshot/OutputChannelRegistrySnapshot.ts';

package/dist/parts/OutputChannel/OutputChannel.js

@@ -1,7 +1,8 @@
 import * as ExtensionApiCommandRegistry from "../ExtensionApiCommandRegistry/ExtensionApiCommandRegistry.js";
 import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import * as OutputChannelStorage from "../OutputChannelStorage/OutputChannelStorage.js";
 const outputChannels = Object.create(null);
-const outputChannelLogs = Object.create(null);
+const outputChannelHandles = Object.create(null);
 let isActivated = false;
 const RE_DASH_CASE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 const assertOutputChannelId = (id) => {
@@ -19,28 +20,35 @@ const assertCanWrite = (id) => {
 };
 class ExtensionOutputChannel {
     #id;
-    constructor(id) {
+    #pendingWrite;
+    constructor(id, pendingWrite) {
         this.#id = id;
+        this.#pendingWrite = pendingWrite;
+    }
+    #queueWrite(write) {
+        this.#pendingWrite = this.#pendingWrite.then(write);
+        return this.#pendingWrite;
     }
     async append(text) {
         assertCanWrite(this.#id);
-        outputChannelLogs[this.#id] += text;
+        await this.#queueWrite(() => OutputChannelStorage.append(this.#id, text));
     }
     async appendLine(text) {
         assertCanWrite(this.#id);
-        outputChannelLogs[this.#id] += `${text}\n`;
+        await this.#queueWrite(() => OutputChannelStorage.append(this.#id, `${text}\n`));
     }
     async clear() {
         assertCanWrite(this.#id);
-        outputChannelLogs[this.#id] = '';
+        await this.#queueWrite(() => OutputChannelStorage.clear(this.#id));
     }
     async getLogs() {
         assertCanWrite(this.#id);
-        return outputChannelLogs[this.#id];
+        await this.#pendingWrite;
+        return OutputChannelStorage.getLogs(this.#id);
     }
     async replace(text) {
         assertCanWrite(this.#id);
-        outputChannelLogs[this.#id] = text;
+        await this.#queueWrite(() => OutputChannelStorage.replace(this.#id, text));
     }
 }
 export const activateOutputChannels = () => {
@@ -54,23 +62,25 @@ export const createOutputChannel = (id) => {
     outputChannels[id] = {
         id,
     };
-    outputChannelLogs[id] = '';
     ExtensionApiCommandRegistry.registerCommandMap(commandMap);
-    return new ExtensionOutputChannel(id);
+    const handle = new ExtensionOutputChannel(id, OutputChannelStorage.clear(id));
+    outputChannelHandles[id] = handle;
+    return handle;
 };
 export const getOutputChannelRegistrySnapshot = () => {
     return {
         outputChannels: Object.values(outputChannels),
     };
 };
-export const getOutputChannelLogs = (id) => {
-    return outputChannelLogs[id];
+export const getOutputChannelLogs = async (id) => {
+    return outputChannelHandles[id]?.getLogs();
 };
-export const clearOutputChannel = (id) => {
-    if (!(id in outputChannelLogs)) {
+export const clearOutputChannel = async (id) => {
+    const handle = outputChannelHandles[id];
+    if (!handle) {
         return false;
     }
-    outputChannelLogs[id] = '';
+    await handle.clear();
     return true;
 };
 const commandMap = {
@@ -82,8 +92,8 @@ export const resetOutputChannelRegistry = () => {
     for (const id of Object.keys(outputChannels)) {
         delete outputChannels[id];
     }
-    for (const id of Object.keys(outputChannelLogs)) {
-        delete outputChannelLogs[id];
+    for (const id of Object.keys(outputChannelHandles)) {
+        delete outputChannelHandles[id];
     }
     isActivated = false;
 };

package/dist/parts/OutputChannelStorage/OutputChannelStorage.d.ts

@@ -0,0 +1,4 @@
+export declare const append: (channelId: string, text: string) => Promise<void>;
+export declare const clear: (channelId: string) => Promise<void>;
+export declare const getLogs: (channelId: string) => Promise<string>;
+export declare const replace: (channelId: string, text: string) => Promise<void>;

package/dist/parts/OutputChannelStorage/OutputChannelStorage.js

@@ -0,0 +1,79 @@
+const databasePrefix = 'lvce-editor-extension-output';
+const databaseVersion = 1;
+const objectStoreName = 'chunks';
+const channelIdIndexName = 'channelId';
+let databasePromise;
+const getDatabaseName = () => {
+    const extensionPath = typeof location === 'undefined' ? 'test' : location.pathname;
+    return `${databasePrefix}:${extensionPath}`;
+};
+const openDatabase = () => {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(getDatabaseName(), databaseVersion);
+        request.onerror = () => reject(request.error);
+        request.onupgradeneeded = () => {
+            const database = request.result;
+            const objectStore = database.createObjectStore(objectStoreName, {
+                autoIncrement: true,
+            });
+            objectStore.createIndex(channelIdIndexName, 'channelId');
+        };
+        request.onsuccess = () => resolve(request.result);
+    });
+};
+const getDatabase = () => {
+    databasePromise ||= openDatabase();
+    return databasePromise;
+};
+const waitForTransaction = (transaction) => {
+    return new Promise((resolve, reject) => {
+        transaction.onabort = () => reject(transaction.error);
+        transaction.onerror = () => reject(transaction.error);
+        transaction.oncomplete = () => resolve();
+    });
+};
+const deleteChannelChunks = (objectStore, channelId, onComplete = () => { }) => {
+    const index = objectStore.index(channelIdIndexName);
+    const request = index.openKeyCursor(IDBKeyRange.only(channelId));
+    request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+            onComplete();
+            return;
+        }
+        objectStore.delete(cursor.primaryKey);
+        cursor.continue();
+    };
+};
+export const append = async (channelId, text) => {
+    const database = await getDatabase();
+    const transaction = database.transaction(objectStoreName, 'readwrite');
+    transaction.objectStore(objectStoreName).add({ channelId, text });
+    await waitForTransaction(transaction);
+};
+export const clear = async (channelId) => {
+    const database = await getDatabase();
+    const transaction = database.transaction(objectStoreName, 'readwrite');
+    deleteChannelChunks(transaction.objectStore(objectStoreName), channelId);
+    await waitForTransaction(transaction);
+};
+export const getLogs = async (channelId) => {
+    const database = await getDatabase();
+    const transaction = database.transaction(objectStoreName, 'readonly');
+    const request = transaction.objectStore(objectStoreName).index(channelIdIndexName).getAll(IDBKeyRange.only(channelId));
+    const chunks = await new Promise((resolve, reject) => {
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+    });
+    await waitForTransaction(transaction);
+    return chunks.map((chunk) => chunk.text).join('');
+};
+export const replace = async (channelId, text) => {
+    const database = await getDatabase();
+    const transaction = database.transaction(objectStoreName, 'readwrite');
+    const objectStore = transaction.objectStore(objectStoreName);
+    deleteChannelChunks(objectStore, channelId, () => {
+        objectStore.add({ channelId, text });
+    });
+    await waitForTransaction(transaction);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/api",
-  "version": "8.81.0",
+  "version": "8.83.0",
   "description": "Tree-shakeable extension API for Lvce Editor extensions.",
   "keywords": [
     "lvce-editor",