dcim-web-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,798 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DCIMUploadPlugin: () => DCIMUploadPlugin,
+  DEFAULT_PLATFORM_ID: () => DEFAULT_PLATFORM_ID,
+  EVENT: () => EVENT,
+  TYPES: () => TYPES,
+  create: () => create,
+  createDcimUploadProvider: () => createDcimUploadProvider,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var EVENT = {
+  SDK_READY: "SDK_READY",
+  SDK_NOT_READY: "SDK_NOT_READY",
+  NET_STATE_CHANGE: "NET_STATE_CHANGE",
+  ERROR: "ERROR",
+  KICKED_OUT: "KICKED_OUT",
+  MESSAGE_RECEIVED: "MESSAGE_RECEIVED",
+  MESSAGE_MODIFIED: "MESSAGE_MODIFIED"
+};
+var TYPES = {
+  CONV_C2C: "C2C"
+};
+var DEFAULT_PLATFORM_ID = 5;
+
+// src/adapters/openim-client-adapter.ts
+var import_client_sdk3 = require("@openim/client-sdk");
+
+// src/emitter.ts
+var SimpleEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(eventName, listener) {
+    const set = this.listeners.get(eventName) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(eventName, set);
+  }
+  off(eventName, listener) {
+    const set = this.listeners.get(eventName);
+    if (!set) return;
+    set.delete(listener);
+    if (set.size === 0) this.listeners.delete(eventName);
+  }
+  emit(eventName, payload) {
+    const set = this.listeners.get(eventName);
+    if (!set) return;
+    set.forEach((listener) => listener(payload));
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/mappers/event.ts
+var import_client_sdk = require("@openim/client-sdk");
+var OPENIM_TO_COMPAT_EVENT = {
+  [import_client_sdk.CbEvents.OnConnectSuccess]: [EVENT.SDK_READY],
+  [import_client_sdk.CbEvents.OnConnecting]: [EVENT.NET_STATE_CHANGE],
+  [import_client_sdk.CbEvents.OnConnectFailed]: [EVENT.SDK_NOT_READY, EVENT.ERROR],
+  [import_client_sdk.CbEvents.OnKickedOffline]: [EVENT.KICKED_OUT],
+  [import_client_sdk.CbEvents.OnUserTokenExpired]: [EVENT.KICKED_OUT],
+  [import_client_sdk.CbEvents.OnUserTokenInvalid]: [EVENT.KICKED_OUT],
+  [import_client_sdk.CbEvents.OnRecvNewMessage]: [EVENT.MESSAGE_RECEIVED],
+  [import_client_sdk.CbEvents.OnRecvNewMessages]: [EVENT.MESSAGE_RECEIVED]
+};
+
+// src/mappers/message.ts
+var import_client_sdk2 = require("@openim/client-sdk");
+
+// src/utils.ts
+var createOperationID = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `dcim_web_sdk_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+};
+var toUnixSeconds = (value) => {
+  if (!value) return void 0;
+  return value > 1e12 ? Math.floor(value / 1e3) : value;
+};
+var inferFileType = (fileName) => {
+  const index = fileName.lastIndexOf(".");
+  if (index < 0) return "";
+  return fileName.slice(index + 1).toLowerCase();
+};
+
+// src/mappers/message.ts
+var mapPictureToImageInfo = (picture, type = 1) => {
+  if (!picture) return void 0;
+  return {
+    type,
+    size: picture.size ?? picture.Size,
+    width: picture.width ?? picture.Width,
+    height: picture.height ?? picture.Height,
+    url: picture.url ?? picture.Url
+  };
+};
+var resolvePicture = (pictureElem, kind) => {
+  if (!pictureElem) return void 0;
+  if (kind === "source") return pictureElem.sourcePicture ?? pictureElem.SourcePicture;
+  if (kind === "big") return pictureElem.bigPicture ?? pictureElem.BigPicture;
+  return pictureElem.snapshotPicture ?? pictureElem.SnapshotPicture;
+};
+var resolveFileField = (fileElem, kind) => {
+  if (!fileElem) return void 0;
+  if (kind === "url") return fileElem.sourceUrl ?? fileElem.sourceURL ?? fileElem.SourceUrl ?? fileElem.SourceURL;
+  if (kind === "name") return fileElem.fileName ?? fileElem.FileName;
+  return fileElem.fileSize ?? fileElem.FileSize;
+};
+var toOptionalString = (value) => {
+  if (value == null) return void 0;
+  return String(value);
+};
+var resolveTextContent = (textElem) => textElem?.content ?? textElem?.Content ?? "";
+var resolveAtText = (atTextElem) => atTextElem?.text ?? atTextElem?.Text ?? "";
+var mapIncomingMessage = (message) => {
+  const base = {
+    ID: message.clientMsgID,
+    cloudCustomData: message.ex ?? "",
+    time: toUnixSeconds(message.sendTime),
+    clientTime: toUnixSeconds(message.createTime),
+    conversationID: message.groupID || message.recvID || message.sendID,
+    _raw: message
+  };
+  switch (message.contentType) {
+    case import_client_sdk2.MessageType.TextMessage: {
+      const textElem = message.textElem;
+      return {
+        ...base,
+        type: "TIMTextElem",
+        payload: {
+          text: resolveTextContent(textElem)
+        }
+      };
+    }
+    case import_client_sdk2.MessageType.AtTextMessage: {
+      const atTextElem = message.atTextElem;
+      return {
+        ...base,
+        type: "TIMTextElem",
+        payload: {
+          text: resolveAtText(atTextElem)
+        }
+      };
+    }
+    case import_client_sdk2.MessageType.PictureMessage: {
+      const pictureElem = message.pictureElem;
+      const sourcePicture = resolvePicture(pictureElem, "source");
+      const source = mapPictureToImageInfo(sourcePicture, 1);
+      const big = mapPictureToImageInfo(resolvePicture(pictureElem, "big"), 2);
+      const snapshot = mapPictureToImageInfo(resolvePicture(pictureElem, "snapshot"), 3);
+      return {
+        ...base,
+        type: "TIMImageElem",
+        payload: {
+          imageInfoArray: [source, big, snapshot].filter(Boolean),
+          imageFormat: toOptionalString(sourcePicture?.type ?? sourcePicture?.Type)
+        }
+      };
+    }
+    case import_client_sdk2.MessageType.FileMessage: {
+      const fileElem = message.fileElem;
+      return {
+        ...base,
+        type: "TIMFileElem",
+        payload: {
+          fileUrl: toOptionalString(resolveFileField(fileElem, "url")),
+          fileName: toOptionalString(resolveFileField(fileElem, "name")),
+          fileSize: resolveFileField(fileElem, "size")
+        }
+      };
+    }
+    default:
+      return null;
+  }
+};
+var buildTextSendResult = (payload, raw) => ({
+  data: { message: { payload: { ...payload } } },
+  message: { payload: { ...payload } },
+  raw
+});
+var buildImageSendResult = (upload, raw) => {
+  const cloneImageInfoArray = () => (upload.imageInfoArray ?? []).map((item) => ({
+    type: item.type,
+    size: item.size,
+    width: item.width,
+    height: item.height,
+    url: item.url
+  }));
+  const payload = {
+    imageInfoArray: cloneImageInfoArray(),
+    imageFormat: upload.imageFormat,
+    url: upload.url
+  };
+  return {
+    data: {
+      message: {
+        payload: {
+          imageInfoArray: cloneImageInfoArray(),
+          imageFormat: payload.imageFormat,
+          url: payload.url
+        }
+      }
+    },
+    message: {
+      payload: {
+        imageInfoArray: cloneImageInfoArray(),
+        imageFormat: payload.imageFormat,
+        url: payload.url
+      }
+    },
+    raw
+  };
+};
+var buildFileSendResult = (upload, fileName, fileSize, raw) => {
+  const payload = {
+    fileUrl: upload.url,
+    url: upload.url,
+    fileName: upload.fileName ?? fileName,
+    fileSize: upload.fileSize ?? fileSize,
+    fileType: upload.fileType ?? inferFileType(fileName)
+  };
+  return {
+    data: { message: { payload: { ...payload } } },
+    message: { payload: { ...payload } },
+    raw
+  };
+};
+var buildLocalTextMessage = (input) => ({
+  to: input.to,
+  conversationType: input.conversationType,
+  type: "TIMTextElem",
+  payload: { text: input.payload.text },
+  cloudCustomData: input.cloudCustomData
+});
+var buildLocalImageMessage = (input) => ({
+  to: input.to,
+  conversationType: input.conversationType,
+  type: "TIMImageElem",
+  payload: {
+    file: input.payload.file,
+    imageInfoArray: [],
+    imageFormat: "",
+    url: "",
+    onProgress: input.onProgress
+  },
+  cloudCustomData: input.cloudCustomData
+});
+var buildLocalFileMessage = (input) => ({
+  to: input.to,
+  conversationType: input.conversationType,
+  type: "TIMFileElem",
+  payload: {
+    file: input.payload.file,
+    fileName: input.payload.file.name,
+    fileSize: input.payload.file.size,
+    fileUrl: "",
+    onProgress: input.onProgress
+  },
+  cloudCustomData: input.cloudCustomData
+});
+
+// src/dcim-upload-plugin.ts
+var DCIMUploadPlugin = { __brand: "dcim-upload-plugin" };
+
+// src/providers.ts
+var joinURL = (baseURL, path) => `${baseURL.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var createFormData = (file, objectName) => {
+  const formData = new FormData();
+  formData.append("file", file, objectName ?? file.name);
+  return formData;
+};
+var canUseXHRUpload = () => typeof XMLHttpRequest !== "undefined";
+var normalizeImageResult = (data) => ({
+  url: data?.url ?? "",
+  uuid: data?.uuid ?? "",
+  imageFormat: data?.imageFormat ?? "",
+  imageInfoArray: data?.imageInfoArray ?? []
+});
+var normalizeFileResult = (data) => ({
+  url: data?.fileUrl ?? data?.url ?? "",
+  uuid: data?.uuid ?? "",
+  fileName: data?.fileName ?? "",
+  fileSize: data?.fileSize ?? 0
+});
+var createDcimUploadProvider = (options) => {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const doUploadByXHR = async (endpoint, file, objectName, onProgress) => {
+    const token = await options.getToken?.();
+    const url = joinURL(options.baseURL, endpoint);
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open("POST", url, true);
+      if (token) xhr.setRequestHeader("token", token);
+      xhr.upload.onprogress = (event) => {
+        if (!onProgress) return;
+        onProgress({
+          loaded: event.loaded,
+          total: event.total,
+          progress: event.lengthComputable && event.total > 0 ? event.loaded / event.total : 0,
+          originalEvent: event
+        });
+      };
+      xhr.onerror = () => {
+        reject(new Error("Upload failed"));
+      };
+      xhr.onload = () => {
+        if (xhr.status < 200 || xhr.status >= 300) {
+          reject(new Error(`Upload failed with status ${xhr.status}`));
+          return;
+        }
+        try {
+          const body = JSON.parse(xhr.responseText);
+          if (body?.errCode && body.errCode !== 0) {
+            reject(new Error(body.errMsg || "Upload failed"));
+            return;
+          }
+          resolve(body?.data ?? body);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      xhr.send(createFormData(file, objectName));
+    });
+  };
+  const doUploadByFetch = async (endpoint, file, objectName) => {
+    const token = await options.getToken?.();
+    const headers = {};
+    if (token) headers.token = token;
+    const response = await fetchImpl(joinURL(options.baseURL, endpoint), {
+      method: "POST",
+      headers,
+      body: createFormData(file, objectName)
+    });
+    if (!response.ok) {
+      throw new Error(`Upload failed with status ${response.status}`);
+    }
+    const body = await response.json();
+    if (body?.errCode && body.errCode !== 0) {
+      throw new Error(body.errMsg || "Upload failed");
+    }
+    return body?.data ?? body;
+  };
+  const doUpload = async (endpoint, file, onProgress) => {
+    const objectName = await options.getObjectName?.(file);
+    if (onProgress && canUseXHRUpload()) {
+      return doUploadByXHR(endpoint, file, objectName, onProgress);
+    }
+    return doUploadByFetch(endpoint, file, objectName);
+  };
+  return {
+    async uploadImage({ file, onProgress }) {
+      const data = await doUpload(options.imageEndpoint ?? "/tencent/uploadImage", file, onProgress);
+      return normalizeImageResult(data);
+    },
+    async uploadFile({ file, onProgress }) {
+      const data = await doUpload(options.fileEndpoint ?? "/tencent/uploadFile", file, onProgress);
+      return normalizeFileResult(data);
+    }
+  };
+};
+
+// src/adapters/openim-client-adapter.ts
+var OpenIMClientAdapter = class {
+  constructor(options) {
+    this.emitter = new SimpleEmitter();
+    this.boundHandlers = [];
+    this.inactiveTimer = null;
+    this.loggingOut = false;
+    this.ready = false;
+    this.logLevel = import_client_sdk3.LogLevel.Info;
+    this.options = options;
+    this.inactiveTimeout = options.inactiveTimeout ?? 0;
+    this.sdk = (0, import_client_sdk3.getSDK)();
+    if (options.debug) this.logLevel = import_client_sdk3.LogLevel.Debug;
+    this.bindSdkEvents();
+  }
+  registerPlugin(plugins) {
+    const candidate = plugins?.["dcim-upload-plugin"];
+    if (!candidate) return;
+    if (candidate === DCIMUploadPlugin) {
+      this.pluginUploader = createDcimUploadProvider({
+        baseURL: this.options.apiAddr,
+        getToken: () => this.token
+      });
+      return;
+    }
+    if (typeof candidate === "object" && "uploadImage" in candidate && "uploadFile" in candidate) {
+      this.pluginUploader = candidate;
+    }
+  }
+  resetInactiveTimer() {
+    if (this.inactiveTimeout <= 0) return;
+    this.clearInactiveTimer();
+    this.inactiveTimer = setTimeout(() => {
+      this.logout().catch(() => {
+      });
+    }, this.inactiveTimeout);
+  }
+  clearInactiveTimer() {
+    if (this.inactiveTimer) {
+      clearTimeout(this.inactiveTimer);
+      this.inactiveTimer = null;
+    }
+  }
+  setLogLevel(level) {
+    if (level <= import_client_sdk3.LogLevel.Trace && level >= import_client_sdk3.LogLevel.Silent) {
+      this.logLevel = level;
+    }
+  }
+  on(eventName, listener) {
+    this.emitter.on(eventName, listener);
+  }
+  off(eventName, listener) {
+    this.emitter.off(eventName, listener);
+  }
+  async login(options) {
+    const token = options.token ?? this.options.token;
+    if (!token) throw new Error("token is required for login");
+    this.token = token;
+    this.loggingOut = false;
+    const userID = options.userID ?? this.options.userID;
+    if (!userID) throw new Error("userID is required for login");
+    const result = await this.sdk.login({
+      userID,
+      token,
+      platformID: DEFAULT_PLATFORM_ID,
+      apiAddr: options.apiAddr ?? this.options.apiAddr,
+      wsAddr: options.wsAddr ?? this.options.wsAddr,
+      logLevel: this.logLevel
+    });
+    this.resetInactiveTimer();
+    return result;
+  }
+  async logout() {
+    this.loggingOut = true;
+    this.ready = false;
+    this.clearInactiveTimer();
+    await this.sdk.logout();
+  }
+  async destroy() {
+    this.loggingOut = true;
+    this.ready = false;
+    this.clearInactiveTimer();
+    try {
+      const status = await this.sdk.getLoginStatus();
+      if (status.data !== import_client_sdk3.LoginStatus.Logout) {
+        await this.sdk.logout();
+      }
+    } catch {
+    }
+    this.boundHandlers.forEach(({ event, handler }) => {
+      this.sdk.off(event, handler);
+    });
+    this.boundHandlers.length = 0;
+    this.emitter.clear();
+  }
+  isReady() {
+    return this.ready;
+  }
+  createTextMessage(input) {
+    return buildLocalTextMessage(input);
+  }
+  createImageMessage(input) {
+    return buildLocalImageMessage(input);
+  }
+  createFileMessage(input) {
+    return buildLocalFileMessage(input);
+  }
+  async sendMessage(message) {
+    let result;
+    switch (message.type) {
+      case "TIMTextElem":
+        result = await this.sendTextMessage(message);
+        break;
+      case "TIMImageElem":
+        result = await this.sendImageMessage(message);
+        break;
+      case "TIMFileElem":
+        result = await this.sendFileMessage(message);
+        break;
+      default:
+        throw new Error(`Unsupported message type: ${message.type}`);
+    }
+    this.resetInactiveTimer();
+    return result;
+  }
+  bindSdkEvents() {
+    const listen = (event, handler) => {
+      this.sdk.on(event, handler);
+      this.boundHandlers.push({ event, handler });
+    };
+    listen(import_client_sdk3.CbEvents.OnConnectSuccess, (payload) => {
+      this.ready = true;
+      this.emitMappedEvents(import_client_sdk3.CbEvents.OnConnectSuccess, payload);
+    });
+    listen(import_client_sdk3.CbEvents.OnConnecting, (payload) => {
+      this.ready = false;
+      this.emitMappedEvents(import_client_sdk3.CbEvents.OnConnecting, {
+        ...payload,
+        data: { state: "CONNECTING" }
+      });
+    });
+    listen(import_client_sdk3.CbEvents.OnConnectFailed, (payload) => {
+      this.ready = false;
+      if (this.loggingOut) return;
+      this.emitMappedEvents(import_client_sdk3.CbEvents.OnConnectFailed, payload);
+    });
+    listen(import_client_sdk3.CbEvents.OnKickedOffline, (payload) => {
+      this.ready = false;
+      this.emitMappedEvents(import_client_sdk3.CbEvents.OnKickedOffline, {
+        ...payload,
+        data: { type: "multipleDevice" }
+      });
+    });
+    listen(import_client_sdk3.CbEvents.OnUserTokenExpired, (payload) => {
+      this.ready = false;
+      this.emitMappedEvents(import_client_sdk3.CbEvents.OnUserTokenExpired, {
+        ...payload,
+        data: { type: "tokenExpired" }
+      });
+    });
+    listen(import_client_sdk3.CbEvents.OnUserTokenInvalid, (payload) => {
+      this.ready = false;
+      this.emitMappedEvents(import_client_sdk3.CbEvents.OnUserTokenInvalid, {
+        ...payload,
+        data: { type: "tokenInvalid" }
+      });
+    });
+    listen(import_client_sdk3.CbEvents.OnRecvNewMessage, (payload) => {
+      this.handleIncomingMessages(payload, false);
+    });
+    listen(import_client_sdk3.CbEvents.OnRecvNewMessages, (payload) => {
+      this.handleIncomingMessages(payload, true);
+    });
+  }
+  emitMappedEvents(event, payload) {
+    const eventNames = OPENIM_TO_COMPAT_EVENT[event] ?? [];
+    eventNames.forEach((eventName) => {
+      if (eventName === EVENT.ERROR) {
+        this.emitter.emit(eventName, {
+          name: eventName,
+          data: {
+            code: payload.errCode,
+            message: payload.errMsg
+          }
+        });
+        return;
+      }
+      this.emitter.emit(eventName, {
+        name: eventName,
+        data: payload.data
+      });
+    });
+  }
+  handleIncomingMessages(payload, multiple) {
+    const rawMessages = multiple ? payload.data ?? [] : [payload.data];
+    const messages = rawMessages.map(mapIncomingMessage).filter(Boolean);
+    if (messages.length === 0) return;
+    this.emitter.emit(EVENT.MESSAGE_RECEIVED, {
+      data: messages
+    });
+  }
+  async sendTextMessage(message) {
+    const text = String(message.payload.text ?? "");
+    const created = await this.wrapSdkCall("createTextMessage", () => this.sdk.createTextMessage(text));
+    const rawMessage = this.attachEx(created.data, message.cloudCustomData);
+    const sent = await this.wrapSdkCall("sendMessage(text)", () => this.sdk.sendMessage({
+      recvID: message.to,
+      groupID: "",
+      message: rawMessage,
+      isOnlineOnly: false
+    }));
+    return buildTextSendResult({ text }, sent);
+  }
+  async sendImageMessage(message) {
+    const file = message.payload.file;
+    if (!(file instanceof File)) throw new Error("image file is required");
+    const uploader = this.options.uploader ?? this.pluginUploader;
+    const upload = uploader ? await uploader.uploadImage({
+      file,
+      onProgress: message.payload.onProgress
+    }) : await this.createNativeImageUpload(file);
+    const imageMessage = await this.wrapSdkCall(
+      "createImageMessageByURL",
+      () => this.sdk.createImageMessageByURL(this.buildImageParams(upload))
+    );
+    const rawMessage = this.attachEx(imageMessage.data, message.cloudCustomData);
+    const sent = await this.wrapSdkCall("sendMessageNotOss(image)", () => this.sdk.sendMessageNotOss({
+      recvID: message.to,
+      groupID: "",
+      message: rawMessage,
+      offlinePushInfo: void 0
+    }));
+    return buildImageSendResult(upload, sent);
+  }
+  async sendFileMessage(message) {
+    const file = message.payload.file;
+    if (!(file instanceof File)) throw new Error("file is required");
+    const uploader = this.options.uploader ?? this.pluginUploader;
+    const upload = uploader ? await uploader.uploadFile({
+      file,
+      onProgress: message.payload.onProgress
+    }) : await this.createNativeFileUpload(file);
+    const fileMessage = await this.wrapSdkCall(
+      "createFileMessageByURL",
+      () => this.sdk.createFileMessageByURL(this.buildFileParams(upload, file))
+    );
+    const rawMessage = this.attachEx(fileMessage.data, message.cloudCustomData);
+    const sent = await this.wrapSdkCall("sendMessageNotOss(file)", () => this.sdk.sendMessageNotOss({
+      recvID: message.to,
+      groupID: "",
+      message: rawMessage,
+      offlinePushInfo: void 0
+    }));
+    return buildFileSendResult(upload, file.name, file.size, sent);
+  }
+  async createNativeImageUpload(file) {
+    const uuid = createOperationID();
+    const created = await this.sdk.createImageMessageByFile({
+      file,
+      sourcePath: file.name,
+      sourcePicture: {
+        uuid,
+        type: inferFileType(file.name),
+        size: file.size,
+        width: 0,
+        height: 0,
+        url: ""
+      },
+      bigPicture: {
+        uuid,
+        type: inferFileType(file.name),
+        size: file.size,
+        width: 0,
+        height: 0,
+        url: ""
+      },
+      snapshotPicture: {
+        uuid,
+        type: inferFileType(file.name),
+        size: file.size,
+        width: 0,
+        height: 0,
+        url: ""
+      }
+    });
+    const data = created.data;
+    return {
+      url: data.pictureElem?.sourcePicture?.url ?? "",
+      uuid: data.pictureElem?.sourcePicture?.uuid ?? uuid,
+      imageFormat: data.pictureElem?.sourcePicture?.type ?? inferFileType(file.name),
+      imageInfoArray: [
+        this.toImageInfo(data.pictureElem?.sourcePicture, 1),
+        this.toImageInfo(data.pictureElem?.bigPicture, 2),
+        this.toImageInfo(data.pictureElem?.snapshotPicture, 3)
+      ].filter((item) => Boolean(item))
+    };
+  }
+  async createNativeFileUpload(file) {
+    const uuid = createOperationID();
+    const created = await this.sdk.createFileMessageByFile({
+      file,
+      filePath: file.name,
+      fileName: file.name,
+      uuid,
+      sourceUrl: "",
+      fileSize: file.size,
+      fileType: inferFileType(file.name)
+    });
+    const data = created.data;
+    return {
+      url: data.fileElem?.sourceUrl ?? "",
+      uuid: data.fileElem?.uuid ?? uuid,
+      fileName: data.fileElem?.fileName ?? file.name,
+      fileSize: data.fileElem?.fileSize ?? file.size,
+      fileType: inferFileType(file.name)
+    };
+  }
+  buildImageParams(upload) {
+    const source = upload.imageInfoArray?.find((item) => item.type === 1) ?? upload.imageInfoArray?.[0];
+    const big = upload.imageInfoArray?.find((item) => item.type === 2) ?? source;
+    const snapshot = upload.imageInfoArray?.find((item) => item.type === 3) ?? source;
+    const format = upload.imageFormat ?? "";
+    const uuid = upload.uuid ?? createOperationID();
+    return {
+      sourcePath: "",
+      sourcePicture: {
+        uuid,
+        type: format,
+        size: source?.size ?? 0,
+        width: source?.width ?? 0,
+        height: source?.height ?? 0,
+        url: source?.url ?? upload.url
+      },
+      bigPicture: {
+        uuid,
+        type: format,
+        size: big?.size ?? source?.size ?? 0,
+        width: big?.width ?? source?.width ?? 0,
+        height: big?.height ?? source?.height ?? 0,
+        url: big?.url ?? upload.url
+      },
+      snapshotPicture: {
+        uuid,
+        type: format,
+        size: snapshot?.size ?? source?.size ?? 0,
+        width: snapshot?.width ?? source?.width ?? 0,
+        height: snapshot?.height ?? source?.height ?? 0,
+        url: snapshot?.url ?? upload.url
+      }
+    };
+  }
+  buildFileParams(upload, file) {
+    return {
+      filePath: "",
+      fileName: upload.fileName ?? file.name,
+      uuid: upload.uuid ?? createOperationID(),
+      sourceUrl: upload.url,
+      fileSize: upload.fileSize ?? file.size,
+      fileType: upload.fileType ?? inferFileType(file.name)
+    };
+  }
+  attachEx(message, cloudCustomData) {
+    const sanitized = cloudCustomData === "null" || cloudCustomData === "undefined" ? "" : cloudCustomData;
+    return {
+      ...message,
+      ex: sanitized ?? message.ex ?? ""
+    };
+  }
+  toImageInfo(picture, type = 1) {
+    if (!picture) return void 0;
+    return {
+      type,
+      size: picture.size,
+      width: picture.width,
+      height: picture.height,
+      url: picture.url
+    };
+  }
+  async wrapSdkCall(label, action) {
+    try {
+      return await action();
+    } catch (error) {
+      throw new Error(`${label} failed: ${this.stringifySdkError(error)}`);
+    }
+  }
+  stringifySdkError(error) {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "string") return error;
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+};
+
+// src/index.ts
+var create = (options) => new OpenIMClientAdapter(options);
+var ChatIMSDK = {
+  EVENT,
+  TYPES,
+  create
+};
+var index_default = ChatIMSDK;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DCIMUploadPlugin,
+  DEFAULT_PLATFORM_ID,
+  EVENT,
+  TYPES,
+  create,
+  createDcimUploadProvider
+});