sprof 0.0.1

package/src/services/Strings.ts

@@ -0,0 +1,138 @@
+export default abstract class Strings {
+  static Capitalize(str: string): string {
+    if (!str) {
+      return '';
+    }
+    return str[0].toUpperCase() + str.slice(1);
+  }
+
+  static ToCamelCase(str: string): string {
+    const wordPattern = new RegExp(
+      ['[А-Я][а-я][A-Z][a-z]+', '[А-Я]+(?=[А-Я][а-я])', '[A-Z]+(?=[A-Z][a-z])', '[А-Я]+', '[A-Z]+', '[а-я]+', '[a-z]+', '[0-9]+'].join('|'),
+      'g'
+    );
+    const parts = str.match(wordPattern) as string[];
+    return parts
+      .map((w: string, i: number) => {
+        return i === 0 ? w.toLowerCase() : Strings.Capitalize(w.toLowerCase());
+      })
+      .join('');
+  }
+
+  static ToKebabCase(str: string): string {
+    return str
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .replace(/[\s_]+/g, '-')
+      .toLowerCase();
+  }
+
+  static GetStringBetweenChars(str: string, first: string, two: string): string {
+    return str.substring(str.indexOf(first) + 2, str.lastIndexOf(two));
+  }
+
+  static Translit(str: string, toEachLang?: boolean): string {
+    const transliter: Record<string, string> = {
+      q: 'й',
+      w: 'ц',
+      e: 'у',
+      r: 'к',
+      t: 'е',
+      y: 'н',
+      u: 'г',
+      i: 'ш',
+      o: 'щ',
+      p: 'з',
+      '[': 'х',
+      ']': 'ъ',
+      a: 'ф',
+      s: 'ы',
+      d: 'в',
+      f: 'а',
+      g: 'п',
+      h: 'р',
+      j: 'о',
+      k: 'л',
+      l: 'д',
+      ';': 'ж',
+      "'": 'э',
+      z: 'я',
+      x: 'ч',
+      c: 'с',
+      v: 'м',
+      b: 'и',
+      n: 'т',
+      m: 'ь',
+      ',': 'б',
+      '.': 'ю',
+      '/': '.',
+    };
+    if (toEachLang && /[а-яА-Я]/g.test(str)) {
+      return str.replace(/[А-я/,.;'\][]/g, (x: string) => {
+        if (x === x.toLowerCase()) {
+          const result = Object.keys(transliter).find((key) => transliter[key] === x);
+          if (result) return result;
+          return '';
+        }
+        const result = Object.keys(transliter).find((key) => transliter[key] === x.toLowerCase());
+        if (result) {
+          return result.toUpperCase();
+        }
+        return '';
+      });
+    }
+    return str.replace(/[A-z/,.;'\][]/g, (x: string) => {
+      return x === x.toLowerCase() ? transliter[x] : transliter[x.toLowerCase()].toUpperCase();
+    });
+  }
+
+  static RemoveEmoji(str: string): string {
+    const emoji = /([\u2700-\u27BF]|[\uE000-\uF8FF]|\uD83C[\uDC00-\uDFFF]|\uD83D[\uDC00-\uDFFF]|[\u2011-\u26FF]|\uD83E[\uDD10-\uDDFF])/g;
+    return str.replace(emoji, '');
+  }
+
+  static CanBeTranslited(str: string): boolean {
+    // eslint-disable-next-line no-useless-escape
+    const regex = /^[~`!@#$%^&*()_+=[\]\\{}|;':",.\/<>?a-zA-Z0-9-]+$/;
+    return regex.test(str);
+  }
+
+  static StringsEquals(str1: string, str2: string): boolean {
+    const low1 = str1.toLowerCase().replaceAll(/\s/g, '');
+    const low2 = str2.toLowerCase().replaceAll(/\s/g, '');
+    const transl1 = Strings.Translit(low1);
+    const transl2 = Strings.Translit(low2);
+    return low1.includes(low2) || transl1.includes(low2) || low1.includes(transl2);
+  }
+
+  static SearchIn(s1: string, s2: string): boolean {
+    return Strings.StringsEquals(s1, s2);
+  }
+
+  static FormatToPercentage(percent: number): string {
+    return `${percent}%`;
+  }
+
+  static WrapSubStr(text: string, subStr: string): string {
+    const re = new RegExp(Strings.GetVariants(subStr).join('|'), 'gi');
+    return text.replace(re, `<span class="search-text">${subStr}</span>`);
+  }
+
+  static GetVariants(s: string): string[] {
+    const st = Strings.Translit(s);
+    return [s, Strings.Capitalize(s), s.toLowerCase(), s.toUpperCase(), st, Strings.Capitalize(st), st.toLowerCase(), st.toUpperCase()];
+  }
+
+  static ContainsNum(str: string): boolean {
+    return /\d/.test(str);
+  }
+  static CreateGuid(): string {
+    const S4 = function () {
+      return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+    };
+    return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+  }
+
+  static JoinSnake(...str: string[]): string {
+    return str.join('_');
+  }
+}

package/src/services/Time.ts

@@ -0,0 +1,124 @@
+import Period from './Period';
+
+
+const Second = 1000;
+const Minute = 60 * Second;
+const Hour = 60 * Minute;
+const Day = 24 * Hour;
+const Week = 7 * Day;
+
+export { Day, Hour, Minute, Second, Week };
+
+export enum TimelineSteps {
+  FiveMinutes = '5',
+  HourQuarter = '15',
+  HourHalf = '30',
+  Hour = '60',
+}
+
+export const TimelineMinutes: Record<TimelineSteps, string[]> = {
+  [TimelineSteps.FiveMinutes]: ['00', '05', '10', '15', '20', '25', '30', '35', '40', '45', '50', '55'],
+  [TimelineSteps.HourQuarter]: ['00', '15', '30', '45'],
+  [TimelineSteps.HourHalf]: ['00', '30'],
+  [TimelineSteps.Hour]: ['00'],
+};
+
+export default abstract class Time {
+  static S(n: number): number {
+    return Second * n
+  }
+  static M(n: number): number {
+    return Minute * n
+  }
+
+  static H(n: number): number {
+    return Hour * n
+  }
+  static D(n: number): number {
+    return Hour * n
+  }
+  static W(n: number): number {
+    return Hour * n
+  }
+
+  static NormalizeTime(m: string | number): string {
+    return String(m).padStart(2, '0');
+  }
+  static HMtoM(time: string): number {
+    const parts = Time.SplitHM(time);
+    if (parts.length > 1) {
+      return Time.HtoM(parts[0]) + parts[1];
+    }
+    return Time.HtoM(parts[0]);
+  }
+
+  static HtoM(h: string | number) {
+    return Number(h) * 60;
+  }
+
+  static SplitHM(time: string): number[] {
+    if (!time) {
+      return [];
+    }
+    const parts = time.split(':');
+    return [Number(parts[0]), Number(parts[1])];
+  }
+
+  static HmsToHm(hms: string): string {
+    const parts = Time.SplitHM(hms);
+    return Time.ConcatHM(parts[0], parts[1]);
+  }
+
+  static AddMtoHM(hm: string, minutes: number): string {
+    const d = new Date();
+    const hmArr = Time.SplitHM(hm);
+    d.setHours(hmArr[0], hmArr[1], 0, 0);
+    const newD = new Date(d.getTime() + minutes * 60000);
+    const h = newD.getHours();
+    const m = newD.getMinutes();
+    return Time.ConcatHM(h, m);
+  }
+
+  static ConcatHM(h: number | string, m: number | string): string {
+    return `${h}:${Time.NormalizeTime(m)}`;
+  }
+
+  static DiffM(t1: string, t2: string): number {
+    return Time.Gt(t2, t1) ? Time.HMtoM(t2) - Time.HMtoM(t1) : Time.HMtoM(t1) - Time.HMtoM(t2);
+  }
+
+  static GetPeriod(t1: string, t2: string): string {
+    return Period.Get(t1, t2);
+  }
+
+  static Gt(t1: string, t2: string): boolean {
+    return Time.HMtoM(t1) > Time.HMtoM(t2);
+  }
+  static GtOrEq(t1: string, t2: string): boolean {
+    return Time.Gt(t1, t2) || Time.Eq(t1, t2);
+  }
+
+  static Eq(t1: string, t2: string): boolean {
+    return Time.HMtoM(t1) === Time.HMtoM(t2);
+  }
+  static PeriodInPeriod(p1Start: string, p1End: string, p2Start: string, p2End: string): boolean {
+    return Time.HMtoM(p1Start) >= Time.HMtoM(p2Start) && Time.HMtoM(p1End) <= Time.HMtoM(p2End);
+  }
+
+  static PeriodsIntersects(p1Start: string, p1End: string, p2Start: string, p2End: string): boolean {
+    return Period.Intersects(Time.HMtoM(p1Start), Time.HMtoM(p1End), Time.HMtoM(p2Start), Time.HMtoM(p2End));
+  }
+}
+
+export const getTimeArray = (): string[] => {
+  const timeArray = [];
+  for (let i = 9; i < 16; ++i) {
+    for (let j = 0; j < 60; j += 10) {
+      const h = i < 10 ? '0' + i : i;
+      const m = j === 0 ? '00' : j;
+      const hm = `${h}:${m}`;
+      timeArray.push(hm);
+    }
+  }
+  return timeArray;
+};

package/src/services/Timer.ts

@@ -0,0 +1,13 @@
+import Time from './Time'
+
+export default abstract class Timer {
+  static Wait<T>(ms: number, v?: T): Promise<T | undefined> {
+    return new Promise((resolve) => setTimeout(() => resolve(v), ms));
+  }
+  static WaitS<T>(s: number, v?: T): Promise<T | undefined> {
+    return Timer.Wait(Time.S(s), v)
+  }
+  static WaitM<T>(m: number, v?: T): Promise<T | undefined> {
+    return Timer.Wait(Time.M(m), v)
+  }
+}

package/src/services/Token.ts

@@ -0,0 +1,71 @@
+import Human from '@/classes/Human';
+import ITokens from '@/interfaces/ITokens';
+
+const TokenService = (() => {
+  function _isAuth(): boolean {
+    const token = _getAccessToken();
+    const u = 'undefined';
+    return !(!token || token === u);
+  }
+
+  function _setToken(tokenObj: ITokens) {
+    if (tokenObj.accessToken) {
+      localStorage.setItem('access_token', tokenObj.accessToken);
+    }
+    if (tokenObj.refreshToken) {
+      localStorage.setItem('refresh_token', tokenObj.refreshToken);
+    }
+  }
+
+  function _getUserId() {
+    const userString = localStorage.getItem('user');
+    if (userString) {
+      return JSON.parse(userString).id;
+    }
+    return '';
+  }
+
+  function _getUser() {
+    const userString = localStorage.getItem('user');
+    if (userString) {
+      return JSON.parse(userString);
+    }
+    return;
+  }
+
+  function _getAccessToken() {
+    return localStorage.getItem('access_token');
+  }
+  function _getRefreshToken() {
+    return localStorage.getItem('refresh_token');
+  }
+  function _clearTokens() {
+    localStorage.removeItem('access_token');
+    localStorage.removeItem('refresh_token');
+  }
+
+  function _updateHuman(human: Human) {
+    if (!_isAuth()) {
+      return;
+    }
+    const user = TokenService.getUser();
+    if (!user) {
+      return;
+    }
+    user.human = human;
+    localStorage.setItem('user', JSON.stringify(user));
+  }
+
+  return {
+    isAuth: _isAuth,
+    setTokens: _setToken,
+    getAccessToken: _getAccessToken,
+    getRefreshToken: _getRefreshToken,
+    getUserId: _getUserId,
+    clearTokens: _clearTokens,
+    getUser: _getUser,
+    updateHuman: _updateHuman,
+  };
+})();
+
+export default TokenService;

package/src/services/Visible.ts

@@ -0,0 +1,16 @@
+export default class Visible {
+  private visible = false;
+
+  protected hide() {
+    this.visible = false;
+  }
+
+  protected show() {
+    this.hide();
+    this.visible = true;
+  }
+
+  IsVisible(): boolean {
+    return this.visible;
+  }
+}

package/src/services/WaitElement.ts

@@ -0,0 +1,19 @@
+export default (selector: string): Promise<unknown> => {
+  return new Promise((resolve) => {
+    if (document.querySelector(selector)) {
+      return resolve(document.querySelector(selector));
+    }
+
+    const observer = new MutationObserver(() => {
+      if (document.querySelector(selector)) {
+        observer.disconnect();
+        resolve(document.querySelector(selector));
+      }
+    });
+
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true,
+    });
+  });
+};

package/src/services/WebSocketClient.ts

@@ -0,0 +1,62 @@
+import ChatMessage from '@/classes/ChatMessage';
+import ClassHelper from '@/services/ClassHelper';
+
+const apiHost = import.meta.env.VITE_APP_API_HOST ?? '';
+export default class WebSocketClient {
+  private client?: WebSocket;
+  private endpoint = '';
+  private query = '';
+  private period = 20000;
+
+  constructor(endpoint = '', query = '', mutation = 'set') {
+    ClassHelper.BuildClass(this, { endpoint, query, mutation });
+    this.connect();
+    this.ping();
+  }
+
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView) {
+    if (!this.client || this.client.readyState !== 1) {
+      return;
+    }
+    this.client.send(data);
+  }
+
+  private ping() {
+    setInterval(this.sendPing.bind(this), this.period);
+  }
+
+  private sendPing() {
+    if (!this.client || this.client.readyState !== 1) {
+      return;
+    }
+    this.send(JSON.stringify(ChatMessage.CreatePingMessage()));
+  }
+
+  setOnMessage(): void {
+    if (!this.client) {
+      return;
+    }
+    // eslint-disable-next-line
+    this.client.onmessage = (e: MessageEvent<any>) => {
+      if (!e.data) {
+        return;
+      }
+      // commit(this.mutation, JSON.parse(e.data));
+    };
+  }
+
+  private buildUrl(): string {
+    const path = `ws/${this.endpoint}/${this.query}`;
+    return new URL(path, apiHost.replace('http', 'ws')).toString();
+  }
+
+  private connect() {
+    this.client = new WebSocket(this.buildUrl());
+    this.client.onclose = this.reconnect;
+    this.client.onerror = this.reconnect;
+  }
+
+  private reconnect() {
+    setTimeout(this.connect, 3000);
+  }
+}

package/src/services/brandColors.ts

@@ -0,0 +1,5 @@
+export const BrandColors: string[] = ['#31af5e', '#ff4d3b', '#006BB5', '#f3911c'];
+
+export default function chooseRandomBrandColor(): string {
+  return BrandColors[Math.floor(Math.random() * BrandColors.length)];
+}

package/src/services/buildNameNumbers.ts

@@ -0,0 +1,8 @@
+export default function buildNameNumbers(array: Array<unknown>, titles: string[]): string {
+  const cases = [2, 0, 1, 1, 1, 2];
+  return (
+    array.length +
+    ' ' +
+    titles[array.length % 100 > 4 && array.length % 100 < 20 ? 2 : cases[array.length % 10 < 5 ? array.length % 10 : 5]]
+  );
+}

package/src/services/countRating.ts

@@ -0,0 +1,12 @@
+type IWithRating = {
+  rating: number;
+};
+
+export default function countRating(items: IWithRating[]): number {
+  const withoutZero = items.filter((o: IWithRating) => o.rating !== 0);
+  let sum = 0;
+  withoutZero.forEach((o: IWithRating) => (sum = sum + o.rating));
+  const rate = sum / withoutZero.length;
+
+  return isNaN(rate) ? 0 : Number((sum / withoutZero.length).toFixed(2));
+}

package/src/services/index.ts

@@ -0,0 +1,105 @@
+//
+import Arrays from "./Arrays";
+import Axios from "./Axios";
+import brandColors from "./brandColors";
+import buildNameNumbers from "./buildNameNumbers";
+import Button from "./Button";
+import Cache from "./Cache";
+import CarouselSwipe from "./CarouselSwipe";
+import Auth from "../classes/Auth";
+import Contact from "../classes/Contact";
+import Email from "../classes/Email";
+import FilterModel from "../classes/filters/FilterModel";
+import FTSP from "../classes/filters/FTSP";
+import SortModel from "../classes/SortModel";
+import ValueType from "../classes/ValueType";
+import ClassHelper from "./ClassHelper";
+import Color from "./Color";
+import countRating from "./countRating";
+import CreateSortModels from "./CreateSortModels";
+import Cursor from "./Cursor";
+import DateFormat from "./DateFormat";
+import DateMask from "./DateMask";
+import Dates from "./Dates";
+import DatesFormatter from "./DatesFormatter";
+import Dragger from "./Dragger";
+import Extension from "./Extension";
+import Favourite from "./Favourite";
+import Hooks from "../Hooks/Hooks";
+import HttpClient from "./HttpClient";
+import MakeCarousel from "./MakeCarousel";
+import { moveDown, moveUp } from "./moves";
+import Period from "./Period";
+import PHelp from "./PHelp";
+import PhoneService from "./PhoneService";
+import Router from "./Router";
+import RouterGuard from "./RouterGuard";
+import Scheduler from "./Scheduler";
+import Scroll from "./Scroll";
+import Sorter from "./Sorter";
+// import Store from './Store';
+import Strings from "./Strings";
+import Time from "./Time";
+import Timer from "./Timer";
+import Token from "./Token";
+import { Sizes } from "../types/Sizes";
+import Statuses from "../types/Statuses";
+import useConfirmLeavePage from "./useConfirmLeavePage";
+import validate from "./validate";
+import WaitElement from "./WaitElement";
+import WebSocketClient from "./WebSocketClient";
+
+export {
+  Arrays,
+  Auth,
+  Axios,
+  brandColors,
+  buildNameNumbers,
+  Button,
+  Cache,
+  CarouselSwipe,
+  ClassHelper,
+  Color,
+  Contact,
+  countRating,
+  CreateSortModels,
+  Cursor,
+  DateFormat,
+  DateMask,
+  Dates,
+  DatesFormatter,
+  Dragger,
+  Email,
+  Extension,
+  Favourite,
+  //
+  FilterModel,
+  FTSP,
+  Hooks,
+  HttpClient,
+  MakeCarousel,
+  moveDown,
+  moveUp,
+  Period,
+  // PHelp
+  PHelp,
+  PhoneService,
+  Router,
+  RouterGuard,
+  Scheduler,
+  Scroll,
+  Sizes,
+  Sorter,
+  SortModel,
+  Statuses,
+  // Store,
+  Strings,
+  Time,
+  Timer,
+  Token,
+  useConfirmLeavePage,
+  validate,
+  ValueType,
+  WaitElement,
+  WebSocketClient,
+};

package/src/services/indexNames.ts

@@ -0,0 +1,55 @@
+const ServicesNames = [
+  'Contact',
+  'Button',
+  'RouterGuard',
+  'Sizes',
+  'Statuses',
+  'Email',
+  'FTSP',
+  'Arrays',
+  'Axios',
+  'brandColors',
+  'buildNameNumbers',
+  'Cache',
+  'CarouselSwipe',
+  'ClassHelper',
+  'Color',
+  'countRating',
+  'CreateSortModels',
+  'Cursor',
+  'DateFormat',
+  'DateMask',
+  'Dates',
+  'DatesFormatter',
+  'Dragger',
+  'Favourite',
+  'Extension',
+  'HttpClient',
+  'MakeCarousel',
+  'moveUp',
+  'moveDown',
+  'Period',
+  'PhoneService',
+  'Router',
+  'Scheduler',
+  'Scroll',
+  'Sorter',
+  // 'Store',
+  'Strings',
+  'Time',
+  'TimeFormatter',
+  'Token',
+  'useConfirmLeavePage',
+  'validate',
+  'WaitElement',
+  'WebSocketClient',
+  'Hooks',
+  'ValueType',
+  'PHelp',
+  'Auth',
+  //
+  'FilterModel',
+  'SortModel',
+];
+
+export default ServicesNames;

package/src/services/moves.ts

@@ -0,0 +1,17 @@
+import IOrdered from '@/interfaces/IOrdered';
+
+export function moveUp(items: IOrdered[], index: number): void {
+  items[index].order = index - 1;
+  if (items[index - 1]) {
+    items[index - 1].order = index;
+  }
+  [items[index], items[index - 1]] = [items[index - 1], items[index]];
+}
+
+export function moveDown(items: IOrdered[], index: number): void {
+  items[index].order = index + 1;
+  if (items[index + 1]) {
+    items[index + 1].order = index;
+  }
+  [items[index], items[index + 1]] = [items[index + 1], items[index]];
+}