@lvce-editor/api 9.12.0 → 9.14.0

package/dist/parts/Rpc/Rpc.d.ts

@@ -1,14 +1,21 @@
 import { type Rpc } from '@lvce-editor/rpc';
-export interface CreateRpcOptions {
+interface CreateRpcBaseOptions {
     readonly commandMap?: Record<string, unknown>;
-    readonly contentSecurityPolicy?: string;
+}
+interface CreateDeclaredRpcOptions extends CreateRpcBaseOptions {
+    readonly id: string;
+}
+interface CreateLegacyRpcOptions extends CreateRpcBaseOptions {
+    readonly contentSecurityPolicy?: readonly string[] | string;
     readonly name?: string;
     readonly url: string;
 }
+export type CreateRpcOptions = CreateDeclaredRpcOptions | CreateLegacyRpcOptions;
 export interface CreateNodeRpcOptions {
     readonly id: string;
     readonly legacyName?: string;
     readonly legacyPath?: string;
 }
-export declare const createRpc: ({ commandMap, contentSecurityPolicy, name, url }: CreateRpcOptions) => Promise<Rpc>;
+export declare const createRpc: (options: CreateRpcOptions) => Promise<Rpc>;
 export declare const createNodeRpc: (options: CreateNodeRpcOptions) => Promise<Rpc>;
+export {};

package/dist/parts/Rpc/Rpc.js

@@ -1,5 +1,23 @@
 import { MessagePortRpcParent, WebSocketRpcParent } from '@lvce-editor/rpc';
 import { ExtensionManagementWorker } from '@lvce-editor/rpc-registry';
+const resolveRpcOptions = async (options) => {
+    if ('id' in options && options.id) {
+        const info = (await ExtensionManagementWorker.invoke('Extensions.getRpcInfo', options.id));
+        return {
+            contentSecurityPolicy: info.contentSecurityPolicy || '',
+            name: info.name || '',
+            url: info.url,
+        };
+    }
+    if ('url' in options && options.url) {
+        return {
+            contentSecurityPolicy: options.contentSecurityPolicy || '',
+            name: options.name || '',
+            url: options.url,
+        };
+    }
+    throw new TypeError('createRpc requires an id or url');
+};
 const sendMessagePortToWebWorker = async (port, contentSecurityPolicy, name, url) => {
     await ExtensionManagementWorker.invokeAndTransfer('Extensions.createWebViewWorkerRpc2', { contentSecurityPolicy, name, url }, port);
 };
@@ -14,7 +32,9 @@ const createMessagePortRpc = async (commandMap, send) => {
     await send(port1);
     return rpcPromise;
 };
-export const createRpc = async ({ commandMap = {}, contentSecurityPolicy = '', name = '', url }) => {
+export const createRpc = async (options) => {
+    const { commandMap = {} } = options;
+    const { contentSecurityPolicy, name, url } = await resolveRpcOptions(options);
     return createMessagePortRpc(commandMap, (port) => sendMessagePortToWebWorker(port, contentSecurityPolicy, name, url));
 };
 const isMissingCommand = (error, command) => {

package/dist/parts/View/View.d.ts

@@ -1,4 +1,5 @@
 import type { VirtualDomNode } from '@lvce-editor/virtual-dom-worker';
+import type { StatusBarItem } from '../StatusBarItem/StatusBarItem.ts';
 export type ViewKind = 'virtualDom';
 export type ViewPreferredLocation = 'preview' | 'sideBar';
 export interface ViewContext {
@@ -56,6 +57,7 @@ export interface VirtualDomViewInstance {
     readonly renderFocus?: (oldContext: Readonly<Record<string, boolean>>, newContext: Readonly<Record<string, boolean>>) => string | Promise<string>;
     readonly renderScrollPosition?: () => readonly [] | ViewScrollPosition | Promise<readonly [] | ViewScrollPosition>;
     readonly renderSelections?: () => readonly ViewSelection[] | Promise<readonly ViewSelection[]>;
+    readonly renderStatusBarItems?: () => readonly StatusBarItem[] | Promise<readonly StatusBarItem[]>;
     readonly renderTitle?: () => string | Promise<string>;
     readonly saveState?: () => unknown;
 }

package/dist/parts/ViewRegistry/ViewRegistry.js

@@ -3,6 +3,7 @@ import { diffTree } from '@lvce-editor/virtual-dom-worker';
 import { registerCommand } from "../CommandRegistry/CommandRegistry.js";
 import * as ExtensionApiCommandRegistry from "../ExtensionApiCommandRegistry/ExtensionApiCommandRegistry.js";
 import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import * as ViewStatusBarItems from "../ViewStatusBarItems/ViewStatusBarItems.js";
 const views = Object.create(null);
 const instances = Object.create(null);
 const instanceUidsByView = Object.create(null);
@@ -420,12 +421,14 @@ const withScrollPosition = async (result, instance) => {
         scrollPosition,
     };
 };
-const withRenderMetadata = async (result, instance, contextChange) => {
+const withRenderMetadata = async (uid, viewId, result, instance, contextChange) => {
     const resultWithCss = await withCss(result, instance);
     const resultWithFocus = await withFocusSelector(resultWithCss, instance, contextChange);
     const resultWithSelections = await withSelections(resultWithFocus, instance);
     const resultWithScrollPosition = await withScrollPosition(resultWithSelections, instance);
-    return withTitle(resultWithScrollPosition, instance);
+    const resultWithTitle = await withTitle(resultWithScrollPosition, instance);
+    await ViewStatusBarItems.renderViewStatusBarItems(uid, viewId, instance);
+    return resultWithTitle;
 };
 const maybeClearContext = async (uid, viewId) => {
     if (!contexts[uid]) {
@@ -469,7 +472,7 @@ export const createViewInstance = async (viewId, uid, context) => {
         type: 'setDom',
     };
     const contextChange = await maybeNotifyContextChanged(uid, viewId, instance);
-    return withRenderMetadata(result, instance, contextChange);
+    return withRenderMetadata(uid, viewId, result, instance, contextChange);
 };
 export const dispatchViewEvent = async (uid, event) => {
     const instance = getVirtualDomInstance(uid);
@@ -488,29 +491,38 @@ export const dispatchViewEvent = async (uid, event) => {
     }
     const result = await renderPatches(uid, instance);
     const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
-    return withRenderMetadata(result, instance, contextChange);
+    return withRenderMetadata(uid, contextViewIds[uid], result, instance, contextChange);
 };
 export const renderViewInstance = async (uid) => {
     const instance = getVirtualDomInstance(uid);
     const result = await renderPatches(uid, instance);
     const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
-    return withRenderMetadata(result, instance, contextChange);
+    return withRenderMetadata(uid, contextViewIds[uid], result, instance, contextChange);
 };
 export const disposeViewInstance = async (uid) => {
     const instance = instances[uid];
-    if (instance && typeof instance.dispose === 'function') {
-        await instance.dispose();
-    }
-    await maybeClearContext(uid, contextViewIds[uid]);
     const viewId = contextViewIds[uid];
-    const instanceUids = instanceUidsByView[viewId];
-    instanceUids?.delete(uid);
-    if (instanceUids?.size === 0) {
-        delete instanceUidsByView[viewId];
+    try {
+        if (instance && typeof instance.dispose === 'function') {
+            await instance.dispose();
+        }
+    }
+    finally {
+        ViewStatusBarItems.disposeViewStatusBarItems(uid);
+        try {
+            await maybeClearContext(uid, viewId);
+        }
+        finally {
+            const instanceUids = instanceUidsByView[viewId];
+            instanceUids?.delete(uid);
+            if (instanceUids?.size === 0) {
+                delete instanceUidsByView[viewId];
+            }
+            delete instances[uid];
+            delete renderedDoms[uid];
+            delete contextViewIds[uid];
+        }
     }
-    delete instances[uid];
-    delete renderedDoms[uid];
-    delete contextViewIds[uid];
 };
 export const saveViewInstanceState = async (uid) => {
     const instance = getVirtualDomInstance(uid);
@@ -563,6 +575,7 @@ const commandMap = {
     'ExtensionApi.saveViewInstanceState': saveViewInstanceState,
 };
 export const resetViewRegistry = () => {
+    ViewStatusBarItems.resetViewStatusBarItems();
     for (const id of Object.keys(views)) {
         for (const disposable of viewCommandDisposables[id] || []) {
             disposable.dispose();

package/dist/parts/ViewStatusBarItems/ViewStatusBarItems.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualDomViewInstance } from '../View/View.ts';
+export declare const renderViewStatusBarItems: (uid: number, viewId: string, instance: VirtualDomViewInstance) => Promise<void>;
+export declare const disposeViewStatusBarItems: (uid: number) => void;
+export declare const resetViewStatusBarItems: () => void;

package/dist/parts/ViewStatusBarItems/ViewStatusBarItems.js

@@ -0,0 +1,90 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import { registerStatusBarItemProvider } from "../StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.js";
+const handlesByUid = Object.create(null);
+const itemsByUid = Object.create(null);
+const stringProperties = ['ariaLabel', 'icon', 'name', 'onClick', 'text', 'title'];
+const normalizeStatusBarItem = (item, index) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+        throw new ExtensionApiError(`view status bar item ${index} must be an object`);
+    }
+    const statusBarItem = item;
+    for (const property of stringProperties) {
+        if (statusBarItem[property] !== undefined && typeof statusBarItem[property] !== 'string') {
+            throw new ExtensionApiError(`view status bar item ${index} has invalid ${property}`);
+        }
+    }
+    if (statusBarItem.spinning !== undefined && typeof statusBarItem.spinning !== 'boolean') {
+        throw new ExtensionApiError(`view status bar item ${index} has invalid spinning`);
+    }
+    return {
+        ...(statusBarItem.ariaLabel !== undefined && { ariaLabel: statusBarItem.ariaLabel }),
+        ...(statusBarItem.icon !== undefined && { icon: statusBarItem.icon }),
+        ...(statusBarItem.name !== undefined && { name: statusBarItem.name }),
+        ...(statusBarItem.onClick !== undefined && { onClick: statusBarItem.onClick }),
+        ...(statusBarItem.spinning !== undefined && { spinning: statusBarItem.spinning }),
+        ...(statusBarItem.text !== undefined && { text: statusBarItem.text }),
+        ...(statusBarItem.title !== undefined && { title: statusBarItem.title }),
+    };
+};
+const normalizeStatusBarItems = (items) => {
+    if (!Array.isArray(items)) {
+        throw new ExtensionApiError('view renderStatusBarItems result must be an array');
+    }
+    return items.map(normalizeStatusBarItem);
+};
+const areItemsEqual = (oldItems, newItems) => {
+    if (oldItems.length !== newItems.length) {
+        return false;
+    }
+    return oldItems.every((oldItem, index) => {
+        const newItem = newItems[index];
+        return (oldItem.ariaLabel === newItem.ariaLabel &&
+            oldItem.icon === newItem.icon &&
+            oldItem.name === newItem.name &&
+            oldItem.onClick === newItem.onClick &&
+            oldItem.spinning === newItem.spinning &&
+            oldItem.text === newItem.text &&
+            oldItem.title === newItem.title);
+    });
+};
+const disposeHandles = (uid) => {
+    for (const handle of handlesByUid[uid] || []) {
+        handle.dispose();
+    }
+    delete handlesByUid[uid];
+};
+const replaceItems = (uid, viewId, items) => {
+    disposeHandles(uid);
+    itemsByUid[uid] = items;
+    handlesByUid[uid] = items.map((_item, index) => registerStatusBarItemProvider({
+        getStatusBarItem() {
+            return itemsByUid[uid]?.[index];
+        },
+        id: `view:${viewId}:${uid}:${index}`,
+    }));
+};
+export const renderViewStatusBarItems = async (uid, viewId, instance) => {
+    if (typeof instance.renderStatusBarItems !== 'function') {
+        return;
+    }
+    const items = normalizeStatusBarItems(await instance.renderStatusBarItems());
+    const oldItems = itemsByUid[uid] || [];
+    if (areItemsEqual(oldItems, items)) {
+        return;
+    }
+    if ((handlesByUid[uid]?.length || 0) !== items.length) {
+        replaceItems(uid, viewId, items);
+        return;
+    }
+    itemsByUid[uid] = items;
+    await Promise.all((handlesByUid[uid] || []).map((handle) => handle.refresh()));
+};
+export const disposeViewStatusBarItems = (uid) => {
+    disposeHandles(uid);
+    delete itemsByUid[uid];
+};
+export const resetViewStatusBarItems = () => {
+    for (const uid of Object.keys(itemsByUid)) {
+        disposeViewStatusBarItems(Number(uid));
+    }
+};

package/package.json

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