@webitel/ui-sdk 0.1.2 → 0.1.3-vue3

package/src/scripts/__tests__/isEmpty.spec.js

@@ -0,0 +1,16 @@
+import isEmpty from '../isEmpty';
+
+describe('isEmpty', () => {
+  it('falsy cases (not empty)', () => {
+    expect(isEmpty(['jest'])).toBeFalsy();
+    expect(isEmpty({ jest: 'jest' })).toBeFalsy();
+    expect(isEmpty(1)).toBeFalsy();
+    expect(isEmpty('jest')).toBeFalsy();
+  });
+  it('truthy cases (empty)', () => {
+    expect(isEmpty([])).toBeTruthy();
+    expect(isEmpty({})).toBeTruthy();
+    expect(isEmpty(0)).toBeTruthy();
+    expect(isEmpty('')).toBeTruthy();
+  });
+});

package/src/scripts/__tests__/prettifyFileSize.spec.js

@@ -0,0 +1,18 @@
+import prettifyFileSize from '../prettifyFileSize';
+
+describe('prettifyFileSize', () => {
+  it('prettifies bytes to kb\'s', () => {
+    const size = 1025;
+    expect(prettifyFileSize(size)).toBe('1 Kb');
+  });
+
+  it('prettifies bytes to mb\'s', () => {
+    const size = 1205 ** 2;
+    expect(prettifyFileSize(size)).toBe('1.38 Mb');
+  });
+
+  it('handles 0 size', () => {
+    const size = 0;
+    expect(prettifyFileSize(size)).toBe('0');
+  });
+});

package/src/scripts/__tests__/prettifyTime.spec.js

@@ -0,0 +1,18 @@
+import prettifyTime from '../prettifyTime';
+
+describe('prettifyTime', () => {
+  it('prettifies date-format time', () => {
+    const time = new Date(0);
+    expect(prettifyTime(time)).toBeTruthy();
+  });
+
+  it('prettifies number-format time', () => {
+    const time = 0;
+    expect(prettifyTime(time)).toBeTruthy();
+  });
+
+  it('prettifies string-format time', () => {
+    const time = '0';
+    expect(prettifyTime(time)).toBeTruthy();
+  });
+});

package/src/scripts/__tests__/preventHiddenPageCallsDecorator.spec.js

@@ -0,0 +1,16 @@
+import preventHiddenPageCallsDecorator from '../preventHiddenPageCallsDecorator';
+
+describe('preventHiddenPageCallsDecorator', () => {
+  it('prevents call on hidden page', () => {
+    let isFnCalled = false;
+    let fn = () => { isFnCalled = true; };
+    fn = preventHiddenPageCallsDecorator(fn, 50);
+    Object.defineProperty(document, 'hidden', {
+      configurable: true,
+      get() { return true; },
+    });
+    expect(isFnCalled).toBeFalsy();
+    fn();
+    expect(isFnCalled).toBeFalsy();
+  });
+});

package/src/scripts/__tests__/sortQueryAdapters.spec.js

@@ -0,0 +1,12 @@
+import * as sortQueryAdapters from '../sortQueryAdapters';
+
+test('sortToQueryAdapter', () => {
+  expect(sortQueryAdapters.sortToQueryAdapter('asc')).toBe('+');
+  expect(sortQueryAdapters.sortToQueryAdapter('desc')).toBe('-');
+  expect(sortQueryAdapters.sortToQueryAdapter(null)).toBe('');
+});
+test('queryToSortAdapter', () => {
+  expect(sortQueryAdapters.queryToSortAdapter('+')).toBe('asc');
+  expect(sortQueryAdapters.queryToSortAdapter('-')).toBe('desc');
+  expect(sortQueryAdapters.queryToSortAdapter('')).toBe(null);
+});

package/src/scripts/caseConverters.js

@@ -0,0 +1,89 @@
+export const snakeToCamel = (str) => str.replace(
+  /([a-z])([_])([a-z])/g,
+  (group, p1, p2, p3) => [p1, p3.toUpperCase()].join(''),
+);
+
+export const camelToSnake = (str) => str.replace(
+  /([a-z])([A-Z])/g,
+  (group, p1, p2) => [p1, '_', p2.toLowerCase()].join(''),
+);
+
+export const kebabToCamel = (str) => str.replace(
+  /([-_][a-z])/g,
+  (group) => group.toUpperCase()
+    .replace('-', ''),
+);
+
+export const camelToKebab = (str) => str.replace(
+  /([A-Z])/g,
+  (group) => group.toLowerCase()
+    .replace('', '-'),
+);
+
+export const kebabToSnake = (str) => str.replace(
+  /([-_][a-z])/g,
+  (group) => group
+    .replace('-', '_'),
+);
+
+export const snakeToKebab = (str) => str.replace(
+  /([-_][a-z])/g,
+  (group) => group
+    .replace('_', '-'),
+);
+
+export const objSnakeToCamel = (obj, skipKeys = []) => {
+  if (!obj) return obj;
+  const newObj = {};
+  if (Array.isArray(obj)) {
+    return obj.map((value) => {
+      if (typeof value === 'object') {
+        return objSnakeToCamel(value, skipKeys);
+      } if (typeof value === 'string') return snakeToCamel(value);
+      return value; // number
+    });
+  }
+  Object.keys(obj)
+    .forEach((oldKey) => {
+      if (skipKeys.includes(oldKey)) {
+        newObj[oldKey] = obj[oldKey];
+      } else {
+        const newKey = snakeToCamel(oldKey);
+        let value = obj[oldKey];
+        if (Array.isArray(value) || (value !== null && value.constructor === Object)) {
+          value = objSnakeToCamel(value, skipKeys);
+        }
+        newObj[newKey] = value;
+      }
+    });
+
+  return newObj;
+};
+
+export const objCamelToSnake = (obj, skipKeys = []) => {
+  if (!obj) return obj;
+  const newObj = {};
+  if (Array.isArray(obj)) {
+    return obj.map((value) => {
+      if (typeof value === 'object') {
+        return objCamelToSnake(value, skipKeys);
+      } if (typeof value === 'string') return camelToSnake(value);
+      return value; // number
+    });
+  }
+  Object.keys(obj)
+    .forEach((oldKey) => {
+      if (skipKeys.includes(oldKey)) {
+        newObj[oldKey] = obj[oldKey];
+      } else {
+        const newKey = camelToSnake(oldKey);
+        let value = obj[oldKey];
+        if (Array.isArray(value) || (value !== null && value.constructor === Object)) {
+          value = objCamelToSnake(value, skipKeys);
+        }
+        newObj[newKey] = value;
+      }
+    });
+
+  return newObj;
+};

package/src/scripts/convertDuration.js

@@ -0,0 +1,15 @@
+const convertDuration = (duration) => {
+  if (!duration) return '00:00:00';
+
+  let hour = `${Math.floor(duration / 3600)}`;
+  let min = `${Math.floor((duration % 3600) / 60)}`;
+  let sec = `${Math.floor((duration % 3600) % 60)}`;
+
+  if (hour.length === 1) hour = `0${hour}`;
+  if (min.length === 1) min = `0${min}`;
+  if (sec.length === 1) sec = `0${sec}`;
+
+  return `${hour}:${min}:${sec}`;
+};
+
+export default convertDuration;

package/src/scripts/editProxy.js

@@ -0,0 +1,9 @@
+const editProxy = (item) => new Proxy(item, {
+  set(obj, prop, value) {
+    obj._dirty = true;
+    obj[prop] = value;
+    return obj;
+  },
+});
+
+export default editProxy;

package/src/scripts/eventBus.js

@@ -0,0 +1,4 @@
+import Vue from 'vue';
+
+const eventBus = new Vue();
+export default eventBus;

package/src/scripts/isEmpty.js

@@ -0,0 +1,9 @@
+// checks if value is Falsy,
+// including empty arrays or objects
+const isEmpty = (value) => {
+  if (Array.isArray(value)) return !value.length;
+  if (typeof value === 'object') return !value || !Object.keys(value).length;
+  return !value;
+};
+
+export default isEmpty;

package/src/scripts/prettifyFileSize.js

@@ -0,0 +1,11 @@
+const prettifyFileSize = (size) => {
+  // eslint-disable-next-line no-param-reassign
+  if (typeof size === 'string') size = +size;
+  if (!size) return '0';
+  const k = 1024;
+  const sizes = ['b', 'Kb', 'Mb', 'Gb', 'Tb', 'Pb', 'Eb', 'Zb', 'Yb'];
+  const i = Math.floor(Math.log(size) / Math.log(k));
+  return `${parseFloat((size / k ** i).toFixed(2))} ${sizes[i]}`;
+};
+
+export default prettifyFileSize;

package/src/scripts/prettifyTime.js

@@ -0,0 +1,9 @@
+const prettifyTime = (time) => {
+  let date;
+  if (time instanceof Date) date = time;
+  else if (typeof time === 'number') date = new Date(time);
+  else date = new Date(+time);
+  return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+};
+
+export default prettifyTime;

package/src/scripts/preventHiddenPageCallsDecorator.js

@@ -0,0 +1,6 @@
+const isPageHidden = () => (
+   document.hidden || document.msHidden || document.webkitHidden || document.mozHidden
+);
+
+const preventHiddenPageCallsDecorator = (method) => (args) => isPageHidden() || method(args);
+export default preventHiddenPageCallsDecorator;

package/src/scripts/sortQueryAdapters.js

@@ -0,0 +1,21 @@
+export const SortSymbols = Object.freeze({
+  ASC: 'asc',
+  DESC: 'desc',
+  NONE: null,
+});
+
+export const sortToQueryAdapter = (order) => {
+  switch (order) {
+    case SortSymbols.ASC: return '+';
+    case SortSymbols.DESC: return '-';
+    default: return '';
+  }
+};
+
+export const queryToSortAdapter = (order) => {
+  switch (order) {
+    case '+': return SortSymbols.ASC;
+    case '-': return SortSymbols.DESC;
+    default: return SortSymbols.NONE;
+  }
+};

package/src/store/BaseStoreModules/BaseStoreModule.js

@@ -0,0 +1,49 @@
+export default class BaseStoreModule {
+  state = {};
+
+  getters = {};
+
+  actions = {};
+
+  mutations = {};
+
+  modules = {};
+
+  attachAPIModule(APIModule) {
+    this._APIModule = APIModule;
+    return this;
+  }
+
+  generateAPIActions() {
+    if (!this._APIModule) throw new ReferenceError('attach API module first!');
+    this.actions.GET_LIST = (context, params = {}) => this._APIModule.getList({ ...context.state, ...params });
+    this.actions.GET_ITEM = (context, params = {}) => this._APIModule.get({ ...context.state, ...params });
+    this.actions.POST_ITEM = (context) => this._APIModule.add(context.state);
+    this.actions.PATCH_ITEM = (context, { id, changes }) => (this._APIModule.patch({ ...context.state, id, changes }));
+    this.actions.UPD_ITEM = (context) => this._APIModule.update(context.state);
+    this.actions.DELETE_ITEM = (context, id) => this._APIModule.delete({ ...context.state, id });
+    return this;
+  }
+
+  setChildModules(modules) {
+    this.modules = modules;
+    return this;
+  }
+
+  getModule({
+              state = {},
+              getters = {},
+              actions = {},
+              mutations = {},
+              namespaced = true,
+            } = {}) {
+    return {
+      namespaced,
+      state: { ...this.state, ...state },
+      getters: { ...this.getters, ...getters },
+      actions: { ...this.actions, ...actions },
+      mutations: { ...this.mutations, ...mutations },
+      modules: this.modules,
+    };
+  }
+}

package/src/store/BaseStoreModules/__tests__/BaseStoreModule.spec.js

@@ -0,0 +1,104 @@
+import BaseStoreModule from '../BaseStoreModule';
+
+const APIModule = {
+  getList: jest.fn(),
+  get: jest.fn(),
+  add: jest.fn(),
+  update: jest.fn(),
+  patch: jest.fn(),
+  delete: jest.fn(),
+};
+
+describe('Base Store Module', () => {
+  let module;
+  beforeEach(() => {
+    module = new BaseStoreModule();
+  });
+  it('attaches api module and generates API actions from it', () => {
+    const _module = module
+      .attachAPIModule(APIModule)
+      .generateAPIActions()
+      .getModule();
+    expect(_module.actions.GET_LIST).toBeTruthy();
+    expect(_module.actions.GET_ITEM).toBeTruthy();
+    expect(_module.actions.POST_ITEM).toBeTruthy();
+    expect(_module.actions.PATCH_ITEM).toBeTruthy();
+    expect(_module.actions.UPD_ITEM).toBeTruthy();
+    expect(_module.actions.DELETE_ITEM).toBeTruthy();
+  });
+  it('generated GET_LIST correctly gets passed params', () => {
+    const state = { jest: 'jest' };
+    const params = { jest2: 'jest1' };
+    const context = { state };
+    const expectedParams = { jest: 'jest', jest2: 'jest1' };
+    const _module = module
+      .attachAPIModule(APIModule)
+      .generateAPIActions()
+      .getModule();
+    _module.actions.GET_LIST(context, params);
+    expect(APIModule.getList).toHaveBeenCalledWith(expectedParams);
+  });
+  it('generated GET_ITEM correctly gets passed params', () => {
+    const state = { jest: 'jest' };
+    const params = { jest2: 'jest1' };
+    const context = { state };
+    const expectedParams = { jest: 'jest', jest2: 'jest1' };
+    const _module = module
+      .attachAPIModule(APIModule)
+      .generateAPIActions()
+      .getModule();
+    _module.actions.GET_ITEM(context, params);
+    expect(APIModule.get).toHaveBeenCalledWith(expectedParams);
+  });
+  it('generated POST_ITEM correctly gets passed params', () => {
+    const state = { jest: 'jest' };
+    const context = { state };
+    const expectedParams = { jest: 'jest' };
+    const _module = module
+      .attachAPIModule(APIModule)
+      .generateAPIActions()
+      .getModule();
+    _module.actions.POST_ITEM(context);
+    expect(APIModule.add).toHaveBeenCalledWith(expectedParams);
+  });
+  it('generated PATCH_ITEM correctly gets passed params', () => {
+    const state = { jest: 'jest' };
+    const params = { id: '1', changes: { jest: 'my change!' } };
+    const context = { state };
+    const expectedParams = { jest: 'jest', id: '1', changes: { jest: 'my change!' } };
+    const _module = module
+      .attachAPIModule(APIModule)
+      .generateAPIActions()
+      .getModule();
+    _module.actions.PATCH_ITEM(context, params);
+    expect(APIModule.patch).toHaveBeenCalledWith(expectedParams);
+  });
+  it('generated UPD_ITEM correctly gets passed params', () => {
+    const state = { jest: 'jest' };
+    const context = { state };
+    const expectedParams = { jest: 'jest' };
+    const _module = module
+      .attachAPIModule(APIModule)
+      .generateAPIActions()
+      .getModule();
+    _module.actions.UPD_ITEM(context);
+    expect(APIModule.update).toHaveBeenCalledWith(expectedParams);
+  });
+  it('generated DELETE_ITEM correctly gets passed params', () => {
+    const state = { jest: 'jest' };
+    const params = '1';
+    const context = { state };
+    const expectedParams = { jest: 'jest', id: '1' };
+    const _module = module
+      .attachAPIModule(APIModule)
+      .generateAPIActions()
+      .getModule();
+    _module.actions.DELETE_ITEM(context, params);
+    expect(APIModule.delete).toHaveBeenCalledWith(expectedParams);
+  });
+  it('sets child modules', () => {
+    const jest = { state: 'jest' };
+    const _module = module.setChildModules({ jest }).getModule();
+    expect(_module.modules).toEqual({ jest });
+  });
+});

package/src/store/helpers/__tests__/getNamespacedState.spec.js

@@ -0,0 +1,11 @@
+import getNamespacedState from '../getNamespacedState';
+
+describe('getNamespacedState', () => {
+  const searchedValue = 'jest!';
+  const state = { lvl1: { lvl2: { lvl3: searchedValue } } };
+
+  it('correctly returns nested object values', () => {
+    const namespace = 'lvl1/lvl2/lvl3';
+    expect(getNamespacedState(state, namespace)).toBe(searchedValue);
+  });
+});

package/src/store/helpers/getNamespacedState.js

@@ -0,0 +1,5 @@
+const getNamespacedState = (state, namespace) => (
+  namespace.split('/').reduce((subState, subNamespace) => subState[subNamespace], state)
+);
+
+export default getNamespacedState;

package/.eslintrc.js

@@ -1,34 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    node: true,
-  },
-  extends: [
-    'plugin:vue/essential',
-    '@vue/airbnb',
-  ],
-  parserOptions: {
-    parser: 'babel-eslint',
-  },
-  rules: {
-    'no-console': 'off',
-    'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off',
-    'no-useless-catch': 'off',
-    'no-shadow': 'off',
-    'no-empty': 'off',
-    'no-underscore-dangle': 'off',
-    'max-len': 'off',
-    indent: 'off',
-  },
-  overrides: [
-    {
-      files: [
-        '**/__tests__/*.{j,t}s?(x)',
-        '**/tests/unit/**/*.spec.{j,t}s?(x)',
-      ],
-      env: {
-        jest: true,
-      },
-    },
-  ],
-};

package/babel.config.js

@@ -1,5 +0,0 @@
-module.exports = {
-  presets: [
-    '@vue/cli-plugin-babel/preset',
-  ],
-};