@opensumi/ide-core-browser 2.23.3-next-1681270416.0 → 2.23.3

package/src/utils/electron.ts

@@ -1,4 +1,4 @@
-import { IDisposable, isUndefined } from '@opensumi/ide-core-common';
+import { IDisposable } from '@opensumi/ide-core-common';
 import { IElectronMainApi } from '@opensumi/ide-core-common/lib/electron';
 import type { MessageConnection } from '@opensumi/vscode-jsonrpc';
 
@@ -12,37 +12,13 @@ export interface IElectronIpcRenderer {
   send(channel: string, ...args: any[]): void;
 }
 
-interface IPCMessage {
-  type: 'event' | 'request' | 'response';
-  service: string;
-  method: string;
-  requestId?: number; // for connecting 'requst' and 'response'
-  args: any[];
-}
-
-const getCapturer = () => {
-  if (window.__OPENSUMI_DEVTOOLS_GLOBAL_HOOK__?.captureIPC) {
-    return window.__OPENSUMI_DEVTOOLS_GLOBAL_HOOK__.captureIPC;
-  }
-  return;
-};
-
-const capture = (message: IPCMessage) => {
-  const capturer = getCapturer();
-  if (!isUndefined(capture)) {
-    // if OpenSumi DevTools is opended
-    capturer(message);
-  }
-};
-
-export function createElectronMainApi(name: string, enableCaptured?: boolean): IElectronMainApi<any> {
+export function createElectronMainApi(name: string): IElectronMainApi<any> {
   let id = 0;
   return new Proxy(
     {
       on: (event: string, listener: (...args) => void): IDisposable => {
         const wrappedListener = (e, eventName, ...args) => {
           if (eventName === event) {
-            enableCaptured && capture({ type: 'event', service: name, method: event, args });
             return listener(...args);
           }
         };
@@ -63,7 +39,6 @@ export function createElectronMainApi(name: string, enableCaptured?: boolean): I
             new Promise((resolve, reject) => {
               const requestId = id++;
               ElectronIpcRenderer.send('request:' + name, method, requestId, ...args);
-              enableCaptured && capture({ type: 'request', service: name, method: String(method), requestId, args });
               const listener = (event, id, error, result) => {
                 if (id === requestId) {
                   ElectronIpcRenderer.removeListener('response:' + name, listener);
@@ -74,14 +49,6 @@ export function createElectronMainApi(name: string, enableCaptured?: boolean): I
                   } else {
                     resolve(result);
                   }
-                  enableCaptured &&
-                    capture({
-                      type: 'response',
-                      service: name,
-                      method: String(method),
-                      requestId,
-                      args: [error, result],
-                    });
                 }
               };
               ElectronIpcRenderer.on('response:' + name, listener);

package/src/utils/index.ts

@@ -2,5 +2,6 @@ export * from './env';
 export * from './electron';
 export * from './react-hooks';
 export * from './icon';
+export * from './parse';
 export * from './json';
 export * from './label';

package/src/utils/label.tsx

@@ -1,4 +1,3 @@
-import clx from 'classnames';
 import React, { CSSProperties } from 'react';
 
 import { Icon } from '@opensumi/ide-components/lib/icon/icon';
@@ -8,42 +7,30 @@ const SEPERATOR = ' ';
 
 export function transformLabelWithCodicon(
   label: string,
-  iconStyleProps: CSSProperties | string = {},
+  iconStyles: CSSProperties = {},
   transformer?: (str: string) => string | undefined,
   renderText?: (str: string, index: number) => React.ReactNode,
 ) {
   const ICON_REGX = /\$\(([a-z.]+\/)?([a-z-]+)(~[a-z]+)?\)/gi;
   const ICON_WITH_ANIMATE_REGX = /\$\(([a-z.]+\/)?([a-z-]+)~([a-z]+)\)/gi;
-  // some string like $() $(~spin)
-  const ICON_ERROR_REGX = /\$\(([a-z.]+\/)?([a-z-]+)?(~[a-z]+)?\)/gi;
-
-  const generateIconStyle = (icon?: string, styleProps?: CSSProperties | string) =>
-    typeof styleProps === 'string' ? { className: clx(icon, styleProps) } : { className: icon, style: styleProps };
-
   return label.split(SEPERATOR).map((e, index) => {
     if (!transformer) {
       return e;
     }
     const icon = transformer(e);
     if (icon) {
-      return <Icon {...generateIconStyle(icon, iconStyleProps)} key={`${index}-${icon}`} />;
+      return <Icon className={icon} style={iconStyles} key={`${index}-${icon}`} />;
     } else if (ICON_REGX.test(e)) {
       if (e.includes('~')) {
         const [, , icon, animate] = ICON_WITH_ANIMATE_REGX.exec(e) || [];
         if (animate && icon) {
           return (
-            <Icon
-              {...generateIconStyle(transformer(`$(${icon})`), iconStyleProps)}
-              animate={animate}
-              key={`${index}-${icon}`}
-            />
+            <Icon className={transformer(`$(${icon})`)} style={iconStyles} animate={animate} key={`${index}-${icon}`} />
           );
         }
       }
       const newStr = e.replaceAll(ICON_REGX, (e) => `${SEPERATOR}${e}${SEPERATOR}`);
-      return transformLabelWithCodicon(newStr, iconStyleProps, transformer);
-    } else if (ICON_ERROR_REGX.test(e)) {
-      return transformLabelWithCodicon(e.replaceAll(ICON_ERROR_REGX, ''), iconStyleProps, transformer, renderText);
+      return transformLabelWithCodicon(newStr, iconStyles, transformer);
     } else {
       return isFunction(renderText) ? renderText(e, index) : <span key={`${index}-${e}`}>{e}</span>;
     }

package/src/utils/parse.ts

@@ -0,0 +1,82 @@
+/** ******************************************************************************
+ * Copyright (C) 2018 Red Hat, Inc. and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+// Some code copied and modified from https://github.com/eclipse-theia/theia/tree/v1.14.0/packages/core/src/browser/label-parser.ts
+
+export interface LabelIcon {
+  name: string;
+  owner?: string;
+  animation?: string;
+}
+
+export namespace LabelIcon {
+  export function is(val: object): val is LabelIcon {
+    return 'name' in val;
+  }
+}
+
+export type LabelPart = string | LabelIcon;
+
+export function parseLabel(text: string): LabelPart[] {
+  const parserArray: LabelPart[] = [];
+  let arrPointer = 0;
+  let potentialIcon = '';
+
+  for (let idx = 0; idx < text.length; idx++) {
+    const char = text.charAt(idx);
+    parserArray[arrPointer] = parserArray[arrPointer] || '';
+    if (potentialIcon === '') {
+      if (char === '$') {
+        potentialIcon += char;
+      } else {
+        parserArray[arrPointer] += char;
+      }
+    } else if (potentialIcon === '$') {
+      if (char === '(') {
+        potentialIcon += char;
+      } else {
+        parserArray[arrPointer] += potentialIcon + char;
+        potentialIcon = '';
+      }
+    } else {
+      if (char === ')') {
+        const iconClassArr = potentialIcon.substring(2, potentialIcon.length).split('~');
+        let name = iconClassArr[0];
+        let owner: string | undefined;
+        if (name) {
+          const index = name.indexOf('/');
+          if (index !== -1) {
+            owner = name.substring(0, index);
+            name = name.substring(index + 1);
+          }
+        }
+        if (parserArray[arrPointer] !== '') {
+          arrPointer++;
+        }
+        parserArray[arrPointer] = { name, owner, animation: iconClassArr[1] };
+        arrPointer++;
+        potentialIcon = '';
+      } else {
+        potentialIcon += char;
+      }
+    }
+  }
+
+  if (potentialIcon !== '') {
+    parserArray[arrPointer] += potentialIcon;
+  }
+
+  return parserArray;
+}