@opensumi/ide-connection 2.27.3-rc-1708399099.0 → 2.27.3-rc-1710386185.0

package/src/common/fury-extends/any.ts

@@ -1,8 +1,6 @@
-import { Uri } from '@opensumi/ide-core-common';
+import { BinaryReader, BinaryWriter } from '@furyjs/fury/dist/lib/type';
 
-import { furyFactory } from './shared';
-
-const { reader, writer } = furyFactory();
+import { Uri, isUint8Array } from '@opensumi/ide-core-common';
 
 export enum ProtocolType {
   String,
@@ -15,119 +13,140 @@ export enum ProtocolType {
   Union,
   Object,
   Undefined,
+  Null,
   Boolean,
 }
 
-function serializeWorker(data: unknown) {
-  if (typeof data === 'undefined') {
-    writer.uint8(ProtocolType.Undefined);
-  } else if (Array.isArray(data)) {
-    writer.uint8(ProtocolType.Array);
-    writer.varUInt32(data.length);
-    for (const element of data) {
-      serializeWorker(element);
-    }
-  } else if (typeof data === 'boolean') {
-    writer.uint8(ProtocolType.Boolean);
-    writer.uint8(data ? 1 : 0);
-  } else if (typeof data === 'number') {
-    if ((data | 0) === data) {
-      writer.uint8(ProtocolType.Int32);
-      writer.int32(data);
-    } else {
-      writer.uint8(ProtocolType.Number);
-      writer.double(data);
+export class AnySerializer {
+  constructor(protected writer: BinaryWriter, protected reader: BinaryReader) {}
+
+  write(data: any) {
+    const { writer } = this;
+    const type = typeof data;
+    writer.reserve(1);
+
+    switch (type) {
+      case 'undefined':
+        writer.uint8(ProtocolType.Undefined);
+        break;
+      case 'string':
+        writer.uint8(ProtocolType.String);
+        writer.stringOfVarUInt32(data);
+        break;
+      case 'boolean':
+        writer.reserve(1);
+        writer.uint8(ProtocolType.Boolean);
+        writer.uint8(data ? 1 : 0);
+        break;
+      case 'number':
+        writer.reserve(8);
+        if ((data | 0) === data) {
+          writer.uint8(ProtocolType.Int32);
+          writer.int32(data);
+        } else {
+          writer.uint8(ProtocolType.Number);
+          writer.double(data);
+        }
+        break;
+      case 'bigint':
+        writer.reserve(8);
+        writer.uint8(ProtocolType.BigInt);
+        writer.int64(data);
+        break;
+      case 'object':
+        if (data === null) {
+          writer.uint8(ProtocolType.Null);
+        } else if (Array.isArray(data)) {
+          writer.reserve(4);
+          writer.uint8(ProtocolType.Array);
+          writer.varUInt32(data.length);
+          for (const element of data) {
+            this.write(element);
+          }
+        } else if (isUint8Array(data)) {
+          writer.reserve(4);
+          writer.uint8(ProtocolType.Buffer);
+          writer.varUInt32(data.byteLength);
+          writer.buffer(data);
+        } else {
+          writer.uint8(ProtocolType.JSONObject);
+          writer.stringOfVarUInt32(JSON.stringify(data, ObjectTransfer.replacer));
+        }
+        break;
+      default:
+        throw new Error(`Unknown type ${type}`);
     }
-  } else if (typeof data === 'string') {
-    writer.uint8(ProtocolType.String);
-    writer.stringOfVarUInt32(data);
-  } else if (data instanceof Uint8Array) {
-    writer.uint8(ProtocolType.Buffer);
-    writer.varUInt32(data.byteLength);
-    writer.buffer(data);
-  } else if (typeof data === 'bigint') {
-    writer.uint8(ProtocolType.BigInt);
-    writer.int64(data);
-  } else if (typeof data === 'object') {
-    writer.uint8(ProtocolType.JSONObject);
-    writer.stringOfVarUInt32(JSON.stringify(data, ObjectTransfer.replacer));
-  } else {
-    throw new Error(`Unknown type ${typeof data}`);
   }
-}
 
-function deserializeWorker() {
-  const type = reader.uint8();
-  switch (type) {
-    case ProtocolType.Undefined:
-      return undefined;
-    case ProtocolType.String:
-      return reader.stringOfVarUInt32();
-    case ProtocolType.Buffer: {
-      const length = reader.varUInt32();
-      return reader.buffer(length);
-    }
-    case ProtocolType.Int32:
-      return reader.int32();
-    case ProtocolType.Number:
-      return reader.double();
-    case ProtocolType.JSONObject: {
-      const json = reader.stringOfVarUInt32();
-      return JSON.parse(json, ObjectTransfer.reviver);
-    }
-    case ProtocolType.BigInt:
-      return reader.int64();
-    case ProtocolType.Array: {
-      const length = reader.varUInt32();
-      const data = [] as unknown[];
-      for (let i = 0; i < length; i++) {
-        data.push(deserializeWorker());
+  read() {
+    const { reader } = this;
+
+    const type = reader.uint8();
+    switch (type) {
+      case ProtocolType.Undefined:
+        return undefined;
+      case ProtocolType.Null:
+        return null;
+      case ProtocolType.String:
+        return reader.stringOfVarUInt32();
+      case ProtocolType.Buffer: {
+        const length = reader.varUInt32();
+        return reader.buffer(length);
+      }
+      case ProtocolType.Int32:
+        return reader.int32();
+      case ProtocolType.Number:
+        return reader.double();
+      case ProtocolType.JSONObject: {
+        const json = reader.stringOfVarUInt32();
+        return JSON.parse(json, ObjectTransfer.reviver);
       }
-      return data;
+      case ProtocolType.BigInt:
+        return reader.int64();
+      case ProtocolType.Array: {
+        const length = reader.varUInt32();
+        const data = [] as unknown[];
+        for (let i = 0; i < length; i++) {
+          data.push(this.read());
+        }
+        return data;
+      }
+      case ProtocolType.Boolean:
+        return reader.uint8() === 1;
+      default:
+        throw new Error(`Unknown type ${type}`);
     }
-    case ProtocolType.Boolean:
-      return reader.uint8() === 1;
-    default:
-      throw new Error(`Unknown type ${type}`);
   }
-}
-
-const deserialize = (bytes: Uint8Array) => {
-  reader.reset(bytes);
-
-  return deserializeWorker();
-};
 
-const serializeVolatile = (v: any) => {
-  writer.reset();
+  deserialize = (bytes: Uint8Array) => {
+    this.reader.reset(bytes);
+    return this.read();
+  };
 
-  serializeWorker(v);
+  serialize = (v: any) => {
+    this.writer.reset();
+    this.write(v);
 
-  return writer.dumpAndOwn();
-};
-
-const serialize = (v: any) => {
-  writer.reset();
-  serializeWorker(v);
-
-  return writer.dump();
-};
+    return this.writer.dump();
+  };
+}
 
-export const anySerializer = {
-  deserialize,
-  serialize,
-  serializeVolatile,
-};
+enum EObjectTransferType {
+  CODE_URI = 'CODE_URI',
+}
 
 class ObjectTransfer {
   static replacer(key: string | undefined, value: any) {
     if (value) {
-      if (value.$mid === 1) {
-        const uri = Uri.revive(value);
-        return {
-          $type: 'VSCODE_URI',
-          data: uri.toString(),
-        };
+      switch (value.$mid) {
+        case 1: {
+          // `$mid === 1` is defined in `vscode-uri` package
+          const uri = Uri.revive(value);
+          return {
+            $type: EObjectTransferType.CODE_URI,
+            data: uri.toString(),
+          };
+        }
       }
     }
 
@@ -135,8 +154,9 @@ class ObjectTransfer {
   }
   static reviver(key: string | undefined, value: any) {
     if (value && value.$type !== undefined && value.data !== undefined) {
-      if (value.$type === 'VSCODE_URI') {
-        return Uri.parse(value.data);
+      switch (value.$type) {
+        case EObjectTransferType.CODE_URI:
+          return Uri.parse(value.data);
       }
     }
     return value;

package/src/common/fury-extends/one-of.ts

@@ -1,61 +1,109 @@
 import { ObjectTypeDescription, Serializer, TypeDescription } from '@furyjs/fury';
 import { generateSerializer } from '@furyjs/fury/dist/lib/gen';
 
-import { furyFactory } from './shared';
-const { fury, reader, writer } = furyFactory();
+import { FuryFactoryReturn, furyFactory } from './shared';
 
 type Writable = Record<string, any> & { kind: string };
 
-export const oneOf = (schemas: TypeDescription[]) => {
-  const registry = new Map<string, Serializer>();
+export const oneOf7 = (
+  schemas: [
+    TypeDescription,
+    TypeDescription,
+    TypeDescription,
+    TypeDescription,
+    TypeDescription,
+    TypeDescription,
+    TypeDescription,
+  ],
+  context?: FuryFactoryReturn,
+) => {
+  if (!context) {
+    context = furyFactory();
+  }
 
-  schemas.forEach((schema) => {
-    registry.set((schema as ObjectTypeDescription).options.tag, generateSerializer(fury, schema));
+  const { fury, reader, writer } = context;
+
+  const serializers = new Array(7) as Serializer[];
+  const kinds = new Array(7) as string[];
+
+  const kindToIndex = {} as Record<string, number>;
+
+  schemas.forEach((schema, i) => {
+    const kind = (schema as ObjectTypeDescription).options.tag;
+    serializers[i] = generateSerializer(fury, schema);
+    kinds[i] = kind;
+    kindToIndex[kind] = i;
   });
 
   const deserialize = (bytes: Uint8Array) => {
     reader.reset(bytes);
-    const kind = reader.stringOfVarUInt32();
-    const serializer = registry.get(kind);
-    if (!serializer) {
-      throw new Error(`Unknown kind: ${kind}`);
-    }
+    const idx = reader.uint8();
 
-    const v = serializer.read();
-    v.kind = kind;
+    let v: any;
+    switch (idx) {
+      case 0:
+        v = serializers[0].read();
+        break;
+      case 1:
+        v = serializers[1].read();
+        break;
+      case 2:
+        v = serializers[2].read();
+        break;
+      case 3:
+        v = serializers[3].read();
+        break;
+      case 4:
+        v = serializers[4].read();
+        break;
+      case 5:
+        v = serializers[5].read();
+        break;
+      case 6:
+        v = serializers[6].read();
+        break;
+    }
 
+    v.kind = kinds[idx];
     return v;
   };
 
-  const serializeVolatile = (v: Writable) => {
-    const serializer = registry.get(v.kind);
-    if (!serializer) {
-      throw new Error(`Unknown kind: ${v.kind}`);
-    }
+  const serialize = (v: Writable) => {
+    const index = kindToIndex[v.kind];
 
     writer.reset();
-    writer.stringOfVarUInt32(v.kind);
-    serializer.write(v);
 
-    return writer.dumpAndOwn();
-  };
+    writer.uint8(index);
 
-  const serialize = (v: Writable) => {
-    const serializer = registry.get(v.kind);
-    if (!serializer) {
-      throw new Error(`Unknown kind: ${v.kind}`);
+    switch (index) {
+      case 0:
+        serializers[0].write(v);
+        break;
+      case 1:
+        serializers[1].write(v);
+        break;
+      case 2:
+        serializers[2].write(v);
+        break;
+      case 3:
+        serializers[3].write(v);
+        break;
+      case 4:
+        serializers[4].write(v);
+        break;
+      case 5:
+        serializers[5].write(v);
+        break;
+      case 6:
+        serializers[6].write(v);
+        break;
     }
 
-    writer.reset();
-    writer.stringOfVarUInt32(v.kind);
-    serializer.write(v);
-
     return writer.dump();
   };
 
   return {
     deserialize,
     serialize,
-    serializeVolatile,
   };
 };

package/src/common/fury-extends/shared.ts

@@ -1,4 +1,5 @@
 import Fury from '@furyjs/fury/dist/lib/fury';
+
 import type { Config } from '@furyjs/fury/dist/lib/type';
 
 export const furyFactory = (config?: Config) => {
@@ -14,3 +15,5 @@ export const furyFactory = (config?: Config) => {
 };
 
 export type FuryFactoryReturn = ReturnType<typeof furyFactory>;
+export type Writer = FuryFactoryReturn['writer'];
+export type Reader = FuryFactoryReturn['reader'];

package/src/common/index.ts

@@ -1,8 +1,8 @@
 export * from './message';
 export * from './rpc-service/proxy';
 export * from './rpc/multiplexer';
-export * from './ext-rpc-protocol';
-export * from './utils';
+export * from './rpcProtocol';
+export * from './capturer';
 export * from './ws-channel';
 export * from './connect';
 export * from './types';

package/src/common/message.ts

@@ -4,7 +4,7 @@ import {
   createMessageConnection,
 } from '@opensumi/vscode-jsonrpc/lib/common/api';
 import { Disposable } from '@opensumi/vscode-jsonrpc/lib/common/disposable';
-import { MessageReader, DataCallback } from '@opensumi/vscode-jsonrpc/lib/common/messageReader';
+import { DataCallback, MessageReader } from '@opensumi/vscode-jsonrpc/lib/common/messageReader';
 import { MessageWriter } from '@opensumi/vscode-jsonrpc/lib/common/messageWriter';
 /**
  * FIXME: 由于 `createMessageConnection` 方法隐式依赖了 `@opensumi/vscode-jsonrpc/lib/browser/main` 或 `@opensumi/vscode-jsonrpc/lib/node/main`