quickblox-react-ui-kit 0.1.0

package/src/qb-api-calls/index.ts

@@ -0,0 +1,543 @@
+import { stringifyError } from '../utils/parse';
+
+export type QBInitParams = {
+  appIdOrToken: string | number;
+  authKeyOrAppId: string | number;
+  authSecret?: string;
+  accountKey: string;
+  config?: QBConfig;
+};
+
+export function QBInit(params: QBInitParams) {
+  QB.init(
+    params.appIdOrToken,
+    params.authKeyOrAppId,
+    params.authSecret,
+    params.accountKey,
+    params.config,
+  );
+}
+
+export function QBCreateSession(params?: QBLoginParams) {
+  return new Promise<QBSession>((resolve, reject) => {
+    QB.createSession(params, (sessionError, session) => {
+      if (sessionError) {
+        reject(stringifyError(sessionError));
+      } else {
+        resolve(session);
+      }
+    });
+  });
+}
+
+export function QBGetSession() {
+  return new Promise<QBSession>((resolve, reject) => {
+    QB.getSession((getSessionError, response) => {
+      if (getSessionError || !response?.session) {
+        reject(
+          getSessionError ? stringifyError(getSessionError) : 'No session',
+        );
+      } else {
+        resolve(response.session);
+      }
+    });
+  });
+}
+
+export function loginToQuickBlox(params: QBLoginParams) {
+  return new Promise<QBUser>((resolve, reject) => {
+    QB.login(params, (loginError, user) => {
+      if (loginError) {
+        reject(stringifyError(loginError));
+      } else {
+        resolve(user);
+      }
+    });
+  });
+}
+
+export function QBLogin(params: QBLoginParams) {
+  let session: QBSession;
+
+  return QBCreateSession()
+    .then((_session) => {
+      session = _session;
+
+      return loginToQuickBlox(params);
+    })
+    .then((user) => ({ user, session }));
+}
+
+export function QBLogout() {
+  return new Promise((resolve) => {
+    QB.destroySession(resolve);
+  });
+}
+
+export function QBChatConnect(params: ChatConnectParams) {
+  return new Promise((resolve, reject) => {
+    QB.chat.connect(params, (error, success) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(success);
+      }
+    });
+  });
+}
+
+export function QBChatDisconnect() {
+  QB.chat.disconnect();
+}
+
+export function registrationAccount(params: QBCreateUserParams) {
+  return new Promise<QBUser>((resolve, reject) => {
+    QB.users.create(params, (error, createdUser) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(createdUser);
+      }
+    });
+  });
+}
+
+export function QBUserCreate(params: QBCreateUserParams) {
+  let session: QBSession;
+
+  return QBCreateSession()
+    .then((_session) => {
+      session = _session;
+
+      return registrationAccount(params);
+    })
+    .then((user) => ({ user, session }));
+}
+
+export function QBUserUpdate(userId: QBUser['id'], user: Partial<QBUser>) {
+  return new Promise<QBUser>((resolve, reject) => {
+    QB.users.update(userId, user, (error, updatedUser) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(updatedUser);
+      }
+    });
+  });
+}
+
+export function QBUserGet(params: GetUserParams | number) {
+  if (typeof params === 'number') {
+    return new Promise<QBUser | undefined>((resolve, reject) => {
+      QB.users.get(params, (error, result) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  }
+
+  return new Promise<ListUserResponse>((resolve, reject) => {
+    QB.users.get(params, (error, result: ListUserResponse) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+//
+export function QBUsersGet(params: GetUserParams) {
+  return new Promise<ListUserResponse>((resolve, reject) => {
+    QB.users.get(params, (error, result: ListUserResponse) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+export function QBUsersGetById(params: number) {
+  return new Promise<QBUser | undefined>((resolve, reject) => {
+    QB.users.get(params, (error, result) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+
+//
+export function QBUserList(params: ListUserParams) {
+  return new Promise<ListUserResponse | undefined>((resolve, reject) => {
+    QB.users.listUsers(params, (error, response) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(response);
+      }
+    });
+  });
+}
+
+export function QBDataGet<T extends QBCustomObject>(
+  className: string,
+  filters: Dictionary<unknown>,
+) {
+  return new Promise<{
+    class_name: string;
+    items: T[];
+    limit: number;
+    skip: number;
+  }>((resolve, reject) => {
+    QB.data.list<T>(className, filters, (error, result) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+
+export function QBDataCreate<T extends QBCustomObject>(
+  className: string,
+  data: Dictionary<unknown>,
+) {
+  return new Promise<T>((resolve, reject) => {
+    QB.data.create<T>(className, data, (error, customObject) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(customObject);
+      }
+    });
+  });
+}
+
+export function QBDataDelete<
+  T extends QBCustomObject['_id'] | Array<QBCustomObject['_id']>,
+>(className: string, ids: T) {
+  return new Promise<QBDataDeletedResponse>((resolve, reject) => {
+    QB.data.delete<T>(className, ids, (error, customObject) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(customObject);
+      }
+    });
+  });
+}
+
+export function QBDataUpdate<T extends QBCustomObject>(
+  className: string,
+  _id: T['_id'],
+  data: Dictionary<unknown>,
+) {
+  return new Promise<T>((resolve, reject) => {
+    QB.data.update<{ _id: string } & Dictionary<unknown>, T>(
+      className,
+      { _id, ...data },
+      (error, item) => {
+        if (error) {
+          reject(stringifyError(error));
+        } else {
+          resolve(item);
+        }
+      },
+    );
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function QBGetDialogs(filters: Dictionary<any>) {
+  return new Promise<QBGetDialogResult | undefined>((resolve, reject) => {
+    QB.chat.dialog.list(filters, (error, result) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+
+export function QBGetDialogById(id: string) {
+  return new Promise<QBGetDialogResult | undefined>((resolve, reject) => {
+    QB.chat.dialog.list({ _id: id }, (error, result) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(result);
+      }
+    });
+  });
+}
+
+export function QBCreatePrivateDialog(
+  userId: QBUser['id'],
+  dialogName?: string,
+  data?: Dictionary<unknown>,
+) {
+  console.log(
+    `call QBCreatePrivateDialog with userid: ${userId} dialog name: ${
+      dialogName || '-'
+    }`,
+  );
+
+  return new Promise<QBChatDialog>((resolve, reject) => {
+    QB.chat.dialog.create(
+      { name: dialogName || '-', occupants_ids: [userId], type: 3, data },
+      (error, chat) => {
+        if (error) {
+          reject(stringifyError(error));
+        } else {
+          resolve(chat);
+        }
+      },
+    );
+  });
+}
+export function QBCreateGroupDialog(
+  userIds: Array<QBUser['id']>,
+  dialogName?: string,
+  data?: Dictionary<unknown>,
+) {
+  console.log(
+    `call QBCreateGroupDialog with ids: ${JSON.stringify(userIds)} name: ${
+      dialogName || ''
+    }`,
+  );
+
+  let params = {};
+
+  if (data && data?.photo) {
+    params = {
+      name: dialogName || '-',
+      occupants_ids: [userIds],
+      type: 2,
+      photo: data?.photo,
+    };
+  } else {
+    params = {
+      name: dialogName || '-',
+      occupants_ids: [userIds],
+      type: 2,
+    };
+  }
+
+  return new Promise<QBChatDialog>((resolve, reject) => {
+    QB.chat.dialog.create(
+      // {
+      //   name: dialogName || '-',
+      //   occupants_ids: [userIds],
+      //   type: 2,
+      //   photo: data?.photo,
+      // },
+      params,
+      (error, chat) => {
+        if (error) {
+          reject(stringifyError(error));
+        } else {
+          resolve(chat);
+        }
+      },
+    );
+  });
+}
+
+export function QBUpdateDialog(
+  dialogId: QBChatDialog['_id'],
+  data: Dictionary<unknown>,
+) {
+  return new Promise<QBChatDialog>((resolve, reject) => {
+    QB.chat.dialog.update(dialogId, data, (error, chat) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(chat);
+      }
+    });
+  });
+}
+
+export function QBJoinDialog(dialogId: QBChatDialog['_id']) {
+  return new Promise((resolve, reject) => {
+    const dialogJid = QB.chat.helpers.getRoomJidFromDialogId(dialogId);
+
+    QB.chat.muc.join(dialogJid, (error, res) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(res);
+      }
+    });
+  });
+}
+
+export function QBDeleteDialog(dialogIds: Array<QBChatDialog['_id']>) {
+  return new Promise<void>((resolve, reject) => {
+    QB.chat.dialog.delete(dialogIds, (error) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+export function QBLeaveDialog(dialogId: QBChatDialog['_id']) {
+  return new Promise((resolve, reject) => {
+    const dialogJid = QB.chat.helpers.getRoomJidFromDialogId(dialogId);
+
+    QB.chat.muc.leave(dialogJid, (error, res) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(res);
+      }
+    });
+  });
+}
+
+export function QBGetInfoFile(fileId: QBContentObject['id']) {
+  return new Promise((resolve, reject) => {
+    QB.content.getInfo(fileId, (error, response) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(response);
+      }
+    });
+  });
+}
+
+export function QBDeleteContent(contentId: QBContentObject['id']) {
+  return new Promise((resolve, reject) => {
+    QB.content.delete(contentId, (error, response) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(response);
+      }
+    });
+  });
+}
+
+export function QBCreateAndUploadContent(paramContent: QBContentParam) {
+  return new Promise((resolve, reject) => {
+    QB.content.createAndUpload(paramContent, (error, response) => {
+      if (error) {
+        reject(stringifyError(error));
+      } else {
+        resolve(response);
+      }
+    });
+  });
+}
+
+export function QBChatGetMessages(
+  dialogId: QBChatDialog['_id'],
+  skip = 0,
+  limit = 100,
+) {
+  return new Promise<GetMessagesResult & { dialogId: QBChatDialog['_id'] }>(
+    (resolve, reject) => {
+      QB.chat.message.list(
+        {
+          chat_dialog_id: dialogId,
+          sort_desc: 'date_sent',
+          limit,
+          skip,
+          mark_as_read: 0,
+        },
+        (error, messages) => {
+          if (error) {
+            reject(stringifyError(error));
+          } else {
+            resolve({ ...messages, dialogId });
+          }
+        },
+      );
+    },
+  );
+}
+//
+export function QBSendIsTypingStatus(
+  dialog: QBChatDialog,
+  senderId: QBUser['id'],
+) {
+  const isPrivate: QBChatDialogType = 3;
+  const jidOrUserid =
+    dialog.type === isPrivate
+      ? QB.chat.helpers.getRecipientId(dialog.occupants_ids, senderId)
+      : QB.chat.helpers.getRoomJidFromDialogId(dialog._id);
+
+  // const dialogJid = QB.chat.helpers.getRoomJidFromDialogId(dialogId);
+
+  try {
+    QB.chat.sendIsTypingStatus(jidOrUserid);
+  } catch (e) {
+    console.log(JSON.stringify(e));
+  }
+}
+export function QBSendIsStopTypingStatus(
+  dialog: QBChatDialog,
+  senderId: QBUser['id'],
+) {
+  const isPrivate: QBChatDialogType = 3;
+  const jidOrUserid =
+    dialog.type === isPrivate
+      ? QB.chat.helpers.getRecipientId(dialog.occupants_ids, senderId)
+      : QB.chat.helpers.getRoomJidFromDialogId(dialog._id);
+
+  // const dialogJid = QB.chat.helpers.getRoomJidFromDialogId(dialogId);
+
+  try {
+    QB.chat.sendIsStopTypingStatus(jidOrUserid);
+  } catch (e) {
+    console.log(JSON.stringify(e));
+  }
+}
+//
+
+export function QBChatSendMessage(to: string, message: QBChatNewMessage) {
+  return new Promise<QBChatMessage['_id']>((resolve) => {
+    resolve(QB.chat.send(to, message));
+  });
+}
+
+export function QBChatSendSystemMessage(
+  to: QBUser['id'] | string,
+  message: { extension: QBSystemMessage['extension'] },
+) {
+  return new Promise<QBSystemMessage['id']>((resolve) => {
+    resolve(QB.chat.sendSystemMessage(to, message));
+  });
+}
+
+export function QBChatMarkMessageRead(params: QBMessageStatusParams) {
+  QB.chat.sendReadStatus(params);
+}
+
+export function QBWebRTCSessionGetUserMedia(
+  session: QBWebRTCSession,
+  params: QBGetUserMediaParams,
+) {
+  return new Promise<MediaStream | undefined>((resolve, reject) => {
+    session.getUserMedia({ ...params }, (error, stream) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(stream);
+      }
+    });
+  });
+}

package/src/react-app-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="react-scripts" />

package/src/setupTests.ts

@@ -0,0 +1,5 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+import '@testing-library/jest-dom';

package/src/utils/DateTimeFormatter.ts

@@ -0,0 +1,35 @@
+export const getDateShortFormatEU = (dateTimeToFormat: number) => {
+  const dateStr = new Date(dateTimeToFormat).toLocaleDateString('en-us', {
+    // dateStyle: 'medium',
+    day: '2-digit',
+    month: 'short',
+    weekday: 'short',
+  });
+  const result = dateStr.split(',');
+  const dayMonthPart = `${result[1]}, ${result[0]}`;
+
+  return dayMonthPart;
+};
+export const getTimeShort24hFormat = (dateTimeToFormat: number) => {
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
+  return new Date(dateTimeToFormat).toLocaleTimeString('en-us', {
+    timeStyle: 'short',
+    hour12: false,
+  });
+};
+
+export const formatShortTime3 = (dateTimeToFormat: number) => {
+  return new Date(dateTimeToFormat).toLocaleTimeString('en-us', {
+    // weekday: 'long',
+    // year: 'numeric',
+    // month: 'long',
+    // day: 'numeric',
+    timeStyle: 'full',
+  });
+};
+export const formatShortTime4 = (dateTimeToFormat: number) => {
+  return new Date(dateTimeToFormat).toLocaleDateString();
+};
+/*
+
+ */

package/src/utils/parse.ts

@@ -0,0 +1,74 @@
+export const jsonParse = <P>(text: string): P | string => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return JSON.parse<P>(text);
+  } catch (error) {
+    return text;
+  }
+};
+
+export const parseErrorObject = (data: Dictionary<string | string[]>) =>
+  Object.keys(data)
+    .map((key) => {
+      const field = data[key];
+
+      return Array.isArray(field)
+        ? `${key} ${field.join('')}`
+        : `${key} ${field}`;
+    })
+    .join(' ')
+    .replace(/errors\s?/, '');
+
+export const parseErrorMessage = (message: string) => {
+  const data = jsonParse<string | string[] | Dictionary<string | string[]>>(
+    message,
+  );
+
+  if (typeof data === 'string') {
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    return data.join('');
+  }
+
+  if (typeof data === 'object') {
+    return parseErrorObject(data);
+  }
+
+  return data;
+};
+
+export function isQBError(error: unknown): error is QBError {
+  return typeof error === 'object' && error !== null && 'message' in error;
+}
+
+export function stringifyError(error: unknown) {
+  if (typeof error === 'string') return error;
+
+  if (error && typeof error === 'object') {
+    const dataError:
+      | { detail?: string; message?: string }
+      | Dictionary<string | string[]> = error;
+
+    if (dataError.detail) {
+      return parseErrorMessage(dataError.detail);
+    }
+
+    if (dataError?.message) {
+      return parseErrorMessage(dataError.message);
+    }
+
+    return parseErrorObject(dataError);
+  }
+
+  return JSON.stringify(error);
+}
+
+export const isSessionDoesNotExistError = (error: string) => {
+  return (
+    error.toUpperCase().replaceAll(' ', '_').replace(/[.:]/g, '') ===
+    'BASE_REQUIRED_SESSION_DOES_NOT_EXIST'
+  );
+};

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist/",
+    "sourceMap": true,
+    "declaration": true,
+    "target": "es5",
+    "lib": [
+      "es2015",
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+  },
+  "include": [
+    "src",
+    "global.d.ts"
+  ],
+  "exclude": ["node_modules", "dist"]
+
+}

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "entryPoints": ["./src/index.ts"],
+  "out": "docs"
+}