@peassoft/mnr-web-topline 0.1.0

package/dist/ru/modules/validators/password-recovery-code.js

@@ -0,0 +1,6 @@
+/**
+ * Validate secret code for password recovery
+ */
+export default function validatePasswordRecoveryCode(secretCode) {
+  return secretCode !== '';
+}

package/dist/ru/modules/validators/password.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Validate password
+ */
+export default function validatePassword(password: string): boolean;

package/dist/ru/modules/validators/password.js

@@ -0,0 +1,6 @@
+/**
+ * Validate password
+ */
+export default function validatePassword(password) {
+  return password !== '';
+}

package/dist/ru/modules/websocket/index.d.ts

@@ -0,0 +1,4 @@
+/** Open websocket */
+export declare function openWebsocket(): void;
+/** Close websocket */
+export declare function closeWebsocket(): void;

package/dist/ru/modules/websocket/index.js

@@ -0,0 +1,92 @@
+import WebError from '@memnrev/web-error';
+import { getWebsocketUrl } from '../env/index.js';
+import { getGrantToken } from '../tokens/index.js';
+import { logError } from '../logger/index.js';
+import { innerToplineService, ToplineEventName } from '../topline-service/index.js';
+import { isObject } from '../../types/helpers.js';
+let activeSocket = null;
+let currConnectionRetries = 0;
+const MAX_RECONNECTION_DELAY_MS = 30000;
+const closeCodes = {
+  // We have closed the connection by ourselves
+  INITIATED_BY_OURSELVES: 1000,
+  // Connection is closed by server
+  INITIATED_BY_SERVER: 1001,
+  // No status code is actually present in a Close control frame
+  WITHOUT_STATUS_CODE: 1005,
+  // Connection was closed abnormally, e.g., without sending or receiving a Close control frame.
+  // This includes the case of connection handshake failure.
+  NETWORK_PROBLEM: 1006,
+  // Grant token is not verified/expired
+  BY_SERVER_INVALID_GRANT_TOKEN: 4401
+};
+/** Handle incoming message from websocket */
+function handleSocketMessage(e) {
+  if (e.data === 'logout') {
+    innerToplineService.processLogout();
+    closeWebsocket();
+  } else {
+    const message = JSON.parse(e.data);
+    if (isObject(message) && 'syncId' in message && typeof message.syncId === 'string') {
+      innerToplineService.emit(ToplineEventName.SyncNotification, message.syncId);
+    }
+  }
+}
+/** Open websocket */
+export function openWebsocket() {
+  closeWebsocket();
+  const wsUrl = getWebsocketUrl();
+  const socket = new window.WebSocket(wsUrl);
+  socket.addEventListener('open', handleSocketOpen);
+  socket.addEventListener('close', e => void handleSocketClose(e));
+  socket.addEventListener('message', handleSocketMessage);
+  activeSocket = socket;
+  currConnectionRetries = 0;
+}
+/** Close websocket */
+export function closeWebsocket() {
+  if (activeSocket) {
+    activeSocket.close(closeCodes.INITIATED_BY_OURSELVES);
+  }
+}
+/** Handle for websocket "open" event */
+function handleSocketOpen() {
+  this.send(JSON.stringify({
+    type: 'connection',
+    data: {
+      grantToken: getGrantToken()
+    }
+  }));
+}
+/** Handle websocket "close" event */
+async function handleSocketClose(e) {
+  activeSocket = null;
+  switch (e.code) {
+    case closeCodes.INITIATED_BY_OURSELVES:
+      break;
+    case closeCodes.INITIATED_BY_SERVER:
+    case closeCodes.WITHOUT_STATUS_CODE:
+    case closeCodes.NETWORK_PROBLEM:
+      reconnect();
+      break;
+    case closeCodes.BY_SERVER_INVALID_GRANT_TOKEN:
+      if (await innerToplineService.upgradeGrantToken()) {
+        reconnect();
+      }
+      break;
+    default:
+      // Unexpected closing code
+      logError(new WebError({
+        name: 'UnexpectedWsClosingCode'
+      }, `websocket was closed with unexpected code ${e.code}`));
+      reconnect();
+  }
+}
+/** Make re-connection try */
+function reconnect() {
+  let delay = 2 ** ++currConnectionRetries * 2000;
+  if (delay > MAX_RECONNECTION_DELAY_MS) {
+    delay = MAX_RECONNECTION_DELAY_MS;
+  }
+  setTimeout(openWebsocket, delay);
+}

package/dist/ru/parts/login/actions/perform-login/index.d.ts

@@ -0,0 +1,27 @@
+import stampit from 'stampit';
+import { getApiBaseUrl, getRequestCredentialsMode } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+import processSuccessfulResponse from '../../../../shared/procedures/process-successful-response/index.js';
+import type { ToplineUser } from '../../../../types/data.js';
+export type ReturnValue = {
+    user: ToplineUser | null;
+    error: 'network' | 'incorrect-credentials' | null;
+};
+/**
+ * Perform logging-in
+ *
+ * Return `null` if login succeeds; otherwise:
+ *   - on network error or if backend responds with 5xx - "network";
+ *   - on login failure - "incorrect-credentials".
+ */
+declare function performLogin(this: This, email: string, password: string): Promise<ReturnValue>;
+export type This = {
+    getApiBaseUrl: typeof getApiBaseUrl;
+    getRequestCredentialsMode: typeof getRequestCredentialsMode;
+    request: typeof request;
+    processSuccessfulResponse: typeof processSuccessfulResponse;
+    performLogin: typeof performLogin;
+};
+export declare const PerformLogin: stampit.Stamp<This>;
+declare const _default: (email: string, password: string) => Promise<ReturnValue>;
+export default _default;

package/dist/ru/parts/login/actions/perform-login/index.js

@@ -0,0 +1,60 @@
+import stampit from 'stampit';
+import { getApiBaseUrl, getRequestCredentialsMode } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+import processSuccessfulResponse from '../../../../shared/procedures/process-successful-response/index.js';
+/**
+ * Perform logging-in
+ *
+ * Return `null` if login succeeds; otherwise:
+ *   - on network error or if backend responds with 5xx - "network";
+ *   - on login failure - "incorrect-credentials".
+ */
+async function performLogin(email, password) {
+  const url = `${this.getApiBaseUrl()}/public/login-with-credentials`;
+  const options = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json; charset=utf-8'
+    },
+    body: JSON.stringify({
+      email,
+      password
+    }),
+    credentials: this.getRequestCredentialsMode(),
+    cache: 'no-store',
+    redirect: 'error'
+  };
+  const response = await this.request(url, options, {
+    maxRetries: 1
+  });
+  if (!response) {
+    return {
+      user: null,
+      error: 'network'
+    };
+  }
+  if (response.status === 200) {
+    return await this.processSuccessfulResponse(response, url);
+  }
+  if (response.status === 401) {
+    return {
+      user: null,
+      error: 'incorrect-credentials'
+    };
+  }
+  // This code is actually unreachable as `request` returns `null` in case of unexpected
+  // status code. The code is added to preserve formal function API.
+  return {
+    user: null,
+    error: 'network'
+  };
+}
+export const PerformLogin = stampit().props({
+  getApiBaseUrl,
+  getRequestCredentialsMode,
+  request,
+  processSuccessfulResponse
+}).methods({
+  performLogin
+});
+export default performLogin.bind(PerformLogin());

package/dist/ru/parts/login/index.d.ts

@@ -0,0 +1 @@
+export { default as Login } from './ui/login/index.js';

package/dist/ru/parts/login/index.js

@@ -0,0 +1 @@
+export { default as Login } from './ui/login/index.js';

package/dist/ru/parts/login/ui/login/index.d.ts

@@ -0,0 +1,8 @@
+import { type JSX } from 'react';
+type Props = {
+    onClose: () => unknown;
+    onMoveToPasswordRecovery: () => unknown;
+    onMoveToSignUp: () => unknown;
+};
+export default function Login(props: Props): JSX.Element;
+export {};

package/dist/ru/parts/login/ui/login/index.js

@@ -0,0 +1,138 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useState, useCallback, useEffect, createRef } from 'react';
+import Modal from '../../../../shared/components/modal/index.js';
+import Alternative from '../../../../shared/components/alternative/index.js';
+import { InputField } from '@peassoft/mnr-web-ui-kit/input-field/index.js';
+import { Button } from '@peassoft/mnr-web-ui-kit/button/index.js';
+import { ErrorMessage } from '@peassoft/mnr-web-ui-kit/error-message/index.js';
+import { ToplineContext } from '../../../shell/index.js';
+import { globalRefs } from '../../../../modules/focus-marshal/index.js';
+import validateEmail from '../../../../modules/validators/email.js';
+import validatePassword from '../../../../modules/validators/password.js';
+import performLogin from '../../actions/perform-login/index.js';
+export default function Login(props) {
+  const {
+    onClose,
+    onMoveToPasswordRecovery,
+    onMoveToSignUp
+  } = props;
+  const lastElementRef = createRef();
+  const [email, setEmail] = useState('');
+  const [isEmailValid, setIsEmailValid] = useState(true);
+  const [password, setPassword] = useState('');
+  const [isPasswordValid, setIsPasswordValid] = useState(true);
+  const [isMakingRequest, setIsMakingRequest] = useState(false);
+  const [errorMessage, setErrorMessage] = useState('');
+  const {
+    handleUserChange
+  } = useContext(ToplineContext);
+  const handleEmailChange = useCallback(newValue => setEmail(newValue.trim()), []);
+  const handlePasswordChange = useCallback(newValue => setPassword(newValue.trim()), []);
+  const handleEmailBlur = useCallback(() => setIsEmailValid(validateEmail(email)), [email]);
+  const handlePasswordBlur = useCallback(() => setIsPasswordValid(validatePassword(password)), [password]);
+  const handleLogInBtnClick = useCallback(async () => {
+    let hasFormValidationFailed = false;
+    if (!validateEmail(email)) {
+      setIsEmailValid(false);
+      hasFormValidationFailed = true;
+    }
+    if (!validatePassword(password)) {
+      setIsPasswordValid(false);
+      hasFormValidationFailed = true;
+    }
+    if (hasFormValidationFailed) return;
+    setIsMakingRequest(true);
+    const {
+      user,
+      error
+    } = await performLogin(email, password);
+    if (user && !error) {
+      onClose();
+      handleUserChange(user);
+      return;
+    }
+    setIsMakingRequest(false);
+    switch (error) {
+      case 'network':
+        setErrorMessage("Сервер недоступен. Попробуйте повторить позже.");
+        break;
+      case 'incorrect-credentials':
+        setErrorMessage("Неправильное имя пользователя и/или пароль.");
+        break;
+      default:
+        throw new Error('Unknown error of a login request');
+    }
+  }, [email, password, onClose, handleUserChange]);
+  const handleTabOnLastElement = useCallback(() => globalRefs.modalFirstItem.current?.focus(), []);
+  const handleShiftTabOnFirstElement = useCallback(() => lastElementRef.current?.focus(), [lastElementRef]);
+  useEffect(() => globalRefs.modalFirstItem.current?.focus(), []);
+  return _jsxs(Modal, {
+    title: "Войти в аккаунт",
+    onClose: onClose,
+    children: [_jsxs("form", {
+      children: [_jsx(InputField, {
+        ref: globalRefs.modalFirstItem,
+        type: 'email',
+        autocompleteAttribute: 'username',
+        label: "Email. Обязательное поле",
+        errorMessage: isEmailValid ? '' : "Введите корректный адрес email",
+        value: email,
+        onChange: handleEmailChange,
+        onBlur: handleEmailBlur,
+        onShiftTab: handleShiftTabOnFirstElement
+      }), _jsx(InputField, {
+        type: 'password',
+        autocompleteAttribute: 'current-password',
+        label: "Пароль. Обязательное поле",
+        errorMessage: isPasswordValid ? '' : "Пароль не может быть пустым",
+        value: password,
+        onChange: handlePasswordChange,
+        onBlur: handlePasswordBlur
+      }), _jsx(Alternative, {
+        condition: () => Boolean(errorMessage),
+        true: _jsx(ErrorMessage, {
+          variant: 'standalone',
+          children: errorMessage
+        }),
+        false: null
+      }), _jsxs("div", {
+        className: 'topline_login_btnsCont',
+        children: [_jsx(Button, {
+          label: "Войти",
+          stretched: true,
+          isInProgress: isMakingRequest,
+          onClick: handleLogInBtnClick
+        }), _jsx(Button, {
+          label: "Отменить",
+          variant: 'secondary',
+          stretched: true,
+          onClick: onClose
+        })]
+      })]
+    }), _jsxs("div", {
+      className: 'topline_login_extraBlock',
+      children: [_jsx("p", {
+        className: 'topline_login_extraBlockLabel',
+        children: "Забыли пароль?"
+      }), _jsx(Button, {
+        label: "Восстановить пароль",
+        variant: 'secondary',
+        size: 'small',
+        onClick: onMoveToPasswordRecovery
+      })]
+    }), _jsxs("div", {
+      className: 'topline_login_extraBlock',
+      children: [_jsx("p", {
+        className: 'topline_login_extraBlockLabel',
+        children: "Нужен аккаунт?"
+      }), _jsx(Button, {
+        ref: lastElementRef,
+        label: "Создай его сейчас!",
+        variant: 'secondary',
+        size: 'small',
+        onClick: onMoveToSignUp,
+        onTab: handleTabOnLastElement
+      })]
+    })]
+  });
+}

package/dist/ru/parts/logout/actions/perform-logout/index.d.ts

@@ -0,0 +1,23 @@
+import stampit from 'stampit';
+import { closeWebsocket } from '../../../../modules/websocket/index.js';
+import { getGrantToken } from '../../../../modules/tokens/index.js';
+import { type InnerService } from '../../../../modules/topline-service/index.js';
+import { getApiBaseUrl } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+import makeSecondAttempt from './make-second-attempt.js';
+export type This = {
+    closeWebsocket: typeof closeWebsocket;
+    getGrantToken: typeof getGrantToken;
+    innerToplineService: Pick<InnerService, 'processLogout' | 'upgradeGrantToken'>;
+    getApiBaseUrl: typeof getApiBaseUrl;
+    request: typeof request;
+    makeSecondAttempt: typeof makeSecondAttempt;
+    performLogout: typeof performLogout;
+};
+export declare const PerformLogout: stampit.Stamp<This>;
+declare const self: () => Promise<void>;
+export default self;
+/**
+ * Make logout request to api
+ */
+declare function performLogout(this: This): Promise<void>;

package/dist/ru/parts/logout/actions/perform-logout/index.js

@@ -0,0 +1,54 @@
+import stampit from 'stampit';
+import { closeWebsocket } from '../../../../modules/websocket/index.js';
+import { getGrantToken } from '../../../../modules/tokens/index.js';
+import { innerToplineService } from '../../../../modules/topline-service/index.js';
+import { getApiBaseUrl } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+import makeSecondAttempt from './make-second-attempt.js';
+export const PerformLogout = stampit().props({
+  closeWebsocket,
+  getGrantToken,
+  innerToplineService,
+  getApiBaseUrl,
+  request,
+  makeSecondAttempt
+}).methods({
+  performLogout
+});
+const self = performLogout.bind(PerformLogout());
+export default self;
+/**
+ * Make logout request to api
+ */
+async function performLogout() {
+  this.closeWebsocket();
+  const grantToken = this.getGrantToken();
+  if (!grantToken) {
+    this.innerToplineService.processLogout();
+    return;
+  }
+  const url = `${this.getApiBaseUrl()}/private/log-out`;
+  const options = {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${grantToken}`
+    },
+    cache: 'no-store',
+    redirect: 'error'
+  };
+  const response = await this.request(url, options, {
+    maxRetries: 1
+  });
+  if (!response || response.status !== 401) {
+    this.innerToplineService.processLogout();
+    return;
+  }
+  if (response.status === 401) {
+    // innerToplineService.upgradeGrantToken() makes all necessary clean-up in case
+    // the upgrade fails
+    const grantToken = await this.innerToplineService.upgradeGrantToken();
+    if (grantToken) {
+      await this.makeSecondAttempt(self);
+    }
+  }
+}

package/dist/ru/parts/logout/actions/perform-logout/make-second-attempt.d.ts

@@ -0,0 +1 @@
+export default function makeSecondAttempt(self: () => Promise<void>): Promise<void>;

package/dist/ru/parts/logout/actions/perform-logout/make-second-attempt.js

@@ -0,0 +1,3 @@
+export default async function makeSecondAttempt(self) {
+  await self();
+}

package/dist/ru/parts/logout/index.d.ts

@@ -0,0 +1 @@
+export { default as performLogout } from './actions/perform-logout/index.js';

package/dist/ru/parts/logout/index.js

@@ -0,0 +1 @@
+export { default as performLogout } from './actions/perform-logout/index.js';

package/dist/ru/parts/password-recovery/actions/create-claim/index.d.ts

@@ -0,0 +1,22 @@
+import stampit from 'stampit';
+import { getApiBaseUrl, getRequestCredentialsMode } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+export type ReturnValue = {
+    error: 'network' | null;
+};
+/**
+ * Create password recovery claim
+ *
+ * Returns `null` if claim creation succeeds; otherwise:
+ *   - on network error or if backend responds with 5xx - "network".
+ */
+declare function createClaim(this: This, email: string): Promise<ReturnValue>;
+export type This = {
+    getApiBaseUrl: typeof getApiBaseUrl;
+    getRequestCredentialsMode: typeof getRequestCredentialsMode;
+    request: typeof request;
+    createClaim: typeof createClaim;
+};
+export declare const CreateClaim: stampit.Stamp<This>;
+declare const _default: (email: string) => Promise<ReturnValue>;
+export default _default;

package/dist/ru/parts/password-recovery/actions/create-claim/index.js

@@ -0,0 +1,41 @@
+import stampit from 'stampit';
+import { getApiBaseUrl, getRequestCredentialsMode } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+/**
+ * Create password recovery claim
+ *
+ * Returns `null` if claim creation succeeds; otherwise:
+ *   - on network error or if backend responds with 5xx - "network".
+ */
+async function createClaim(email) {
+  const url = `${this.getApiBaseUrl()}/public/create-password-recovery-claim`;
+  const options = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json; charset=utf-8'
+    },
+    body: JSON.stringify({
+      email
+    }),
+    credentials: this.getRequestCredentialsMode(),
+    cache: 'no-store',
+    redirect: 'error'
+  };
+  const response = await this.request(url, options);
+  if (!response) {
+    return {
+      error: 'network'
+    };
+  }
+  return {
+    error: null
+  };
+}
+export const CreateClaim = stampit().props({
+  getApiBaseUrl,
+  getRequestCredentialsMode,
+  request
+}).methods({
+  createClaim
+});
+export default createClaim.bind(CreateClaim());

package/dist/ru/parts/password-recovery/actions/save-password/index.d.ts

@@ -0,0 +1,27 @@
+import stampit from 'stampit';
+import { getApiBaseUrl, getRequestCredentialsMode } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+import processSuccessfulResponse from '../../../../shared/procedures/process-successful-response/index.js';
+import type { ToplineUser } from '../../../../types/data.js';
+export type ReturnValue = {
+    user: ToplineUser | null;
+    error: 'network' | 'no-claim' | null;
+};
+/**
+ * Save new password
+ *
+ * Returns `null` if sign-up succeeds; otherwise:
+ *   - on network error or if backend responds with 5xx - "network";
+ *   - on 403 Forbidden response - "no-claim".
+ */
+declare function savePassword(this: This, email: string, password: string, secretCode: string): Promise<ReturnValue>;
+export type This = {
+    getApiBaseUrl: typeof getApiBaseUrl;
+    getRequestCredentialsMode: typeof getRequestCredentialsMode;
+    request: typeof request;
+    processSuccessfulResponse: typeof processSuccessfulResponse;
+    savePassword: typeof savePassword;
+};
+export declare const SavePassword: stampit.Stamp<This>;
+declare const _default: (email: string, password: string, secretCode: string) => Promise<ReturnValue>;
+export default _default;

package/dist/ru/parts/password-recovery/actions/save-password/index.js

@@ -0,0 +1,61 @@
+import stampit from 'stampit';
+import { getApiBaseUrl, getRequestCredentialsMode } from '../../../../modules/env/index.js';
+import request from '../../../../modules/request/index.js';
+import processSuccessfulResponse from '../../../../shared/procedures/process-successful-response/index.js';
+/**
+ * Save new password
+ *
+ * Returns `null` if sign-up succeeds; otherwise:
+ *   - on network error or if backend responds with 5xx - "network";
+ *   - on 403 Forbidden response - "no-claim".
+ */
+async function savePassword(email, password, secretCode) {
+  const url = `${this.getApiBaseUrl()}/public/create-new-password`;
+  const options = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json; charset=utf-8'
+    },
+    body: JSON.stringify({
+      email,
+      password,
+      secretCode
+    }),
+    credentials: this.getRequestCredentialsMode(),
+    cache: 'no-store',
+    redirect: 'error'
+  };
+  const response = await this.request(url, options, {
+    expectedStatusCodes: [200, 403]
+  });
+  if (!response) {
+    return {
+      user: null,
+      error: 'network'
+    };
+  }
+  if (response.status === 200) {
+    return await this.processSuccessfulResponse(response, url);
+  }
+  if (response.status === 403) {
+    return {
+      user: null,
+      error: 'no-claim'
+    };
+  }
+  // This code is actually unreachable as `request` returns `null` in case of unexpected
+  // status code. The code is added to preserve formal function API.
+  return {
+    user: null,
+    error: 'network'
+  };
+}
+export const SavePassword = stampit().props({
+  getApiBaseUrl,
+  getRequestCredentialsMode,
+  request,
+  processSuccessfulResponse
+}).methods({
+  savePassword
+});
+export default savePassword.bind(SavePassword());

package/dist/ru/parts/password-recovery/index.d.ts

@@ -0,0 +1 @@
+export { default as PasswordRecovery } from './ui/password-recovery/index.js';

package/dist/ru/parts/password-recovery/index.js

@@ -0,0 +1 @@
+export { default as PasswordRecovery } from './ui/password-recovery/index.js';

package/dist/ru/parts/password-recovery/ui/password-recovery/index.d.ts

@@ -0,0 +1,6 @@
+import { type JSX } from 'react';
+type Props = {
+    onClose: () => unknown;
+};
+export default function PasswordRecovery(props: Props): JSX.Element;
+export {};

package/dist/ru/parts/password-recovery/ui/password-recovery/index.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useCallback } from 'react';
+import Modal from '../../../../shared/components/modal/index.js';
+import Alternative from '../../../../shared/components/alternative/index.js';
+import StepOne from '../step-one/index.js';
+import StepTwo from '../step-two/index.js';
+export default function PasswordRecovery(props) {
+  const {
+    onClose
+  } = props;
+  const [step, setStep] = useState(1);
+  const [email, setEmail] = useState('');
+  const condition = useCallback(() => step === 1, [step]);
+  const onNext = useCallback(email => {
+    setEmail(email);
+    setStep(2);
+  }, []);
+  return _jsx(Modal, {
+    title: "Восстановление пароля",
+    onClose: onClose,
+    children: _jsx(Alternative, {
+      condition: condition,
+      true: _jsx(StepOne, {
+        onNext: onNext,
+        onClose: onClose
+      }),
+      false: _jsx(StepTwo, {
+        email: email,
+        onClose: onClose
+      })
+    })
+  });
+}

package/dist/ru/parts/password-recovery/ui/step-one/index.d.ts

@@ -0,0 +1,7 @@
+import { type JSX } from 'react';
+type Props = {
+    onNext: (email: string) => unknown;
+    onClose: () => unknown;
+};
+export default function StepOne(props: Props): JSX.Element;
+export {};