@webitel/ui-sdk 0.1.13 → 0.1.100

package/src/modules/Userinfo/store/UserinfoStoreModule.js

@@ -0,0 +1,112 @@
+import userinfo from '../api/userinfo';
+import ApplicationsAccess from '../classes/ApplicationsAccess';
+import BaseStoreModule from '../../../store/BaseStoreModules/BaseStoreModule';
+
+const defaultState = () => ({
+  isLoading: true,
+  domainId: 0,
+  name: '',
+  username: '',
+  account: '',
+  userId: 0,
+  scope: {},
+  permissions: {},
+  roles: [],
+  license: [],
+  access: {},
+  language: localStorage.getItem('lang'),
+});
+
+export default class UserinfoStoreModule extends BaseStoreModule {
+  state = {
+    ...defaultState(),
+  }
+
+  getters = {
+    THIS_APP: (state) => state.thisApp,
+    // if no access[app] => accessed by default
+    CHECK_APP_ACCESS: (state) => (app) => !state.access[app] || state.access[app]?._enabled,
+    CHECK_OBJECT_ACCESS: (state, getters) => ({ name, route }) => {
+      if (!state.access[getters.THIS_APP] || !state.access[getters.THIS_APP]._enabled) return false;
+      if (route) return getters.CHECK_OBJECT_ACCESS_BY_ROUTE(route);
+      return getters.CHECK_OBJECT_ACCESS_BY_NAME(name);
+    },
+    CHECK_OBJECT_ACCESS_BY_NAME: (state, getters) => (name) => (
+      state.access[getters.THIS_APP][name]?._enabled
+    ),
+    CHECK_OBJECT_ACCESS_BY_ROUTE: (state, getters) => (route) => {
+      const accessKey = Object.keys(state.access[getters.THIS_APP]).find((object) => route.name.includes(object));
+      return state.access[getters.THIS_APP][accessKey]?._enabled;
+    },
+  }
+
+  actions = {
+    BEFORE_OPEN_SESSION_HOOK: () => {},
+    AFTER_OPEN_SESSION_HOOK: () => {},
+    CONVERT_USER_SCOPE: (context, scope) => scope,
+    CONVERT_USER_PERMISSIONS: (context, permissions) => permissions,
+
+    OPEN_SESSION: async (context) => {
+      await context.dispatch('BEFORE_OPEN_SESSION_HOOK');
+      // !!! it should be checked in router.js beforeEach hook
+      // if (!localStorage.getItem('access-token')) {
+      //   context.dispatch('REDIRECT_TO_AUTH');
+      //   throw new Error('No access-token in localStorage');
+      // }
+      const session = await userinfo.getSession();
+      await context.dispatch('SET_SESSION', session);
+      const access = await userinfo.getApplicationsAccess();
+      await context.dispatch('SET_APPLICATIONS_ACCESS', new ApplicationsAccess({ access }).getAccess());
+      await context.dispatch('AFTER_OPEN_SESSION_HOOK');
+    },
+    SET_SESSION: async (context, _session) => {
+      const defaultSession = {
+        domainId: 0,
+        username: '',
+        userId: 0,
+        scope: [],
+        roles: [],
+        license: [],
+      };
+
+      try {
+        await context.dispatch('RESET_STATE');
+        const session = { ...defaultSession, ..._session };
+        const scope = await context.dispatch('CONVERT_USER_SCOPE', session.scope);
+        const permissions = await context.dispatch('CONVERT_USER_PERMISSIONS', session.permissions);
+        context.commit('SET_SESSION', { ...session, scope, permissions });
+        await context.dispatch('SET_LOADING', false);
+      } catch (err) {
+        throw err;
+      }
+    },
+
+    SET_APPLICATIONS_ACCESS: (context, access) => context.commit('SET_APPLICATIONS_ACCESS', access),
+
+    SET_LOADING: (context, isLoading) => {
+      context.commit('SET_LOADING', isLoading);
+    },
+
+    RESET_STATE: (context) => {
+      context.commit('RESET_STATE');
+    },
+  }
+
+  mutations = {
+    SET_SESSION: (state, session) => {
+      Object.assign(state, session);
+    },
+
+    SET_APPLICATIONS_ACCESS: (state, access) => {
+      state.access = access;
+    },
+
+    SET_LOADING: (state, isLoading) => {
+      state.isLoading = isLoading;
+    },
+
+    RESET_STATE: (state) => {
+      Object.assign(state, defaultState());
+    },
+  }
+}

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

@@ -0,0 +1,72 @@
+import {
+  camelToKebab,
+  camelToSnake,
+  kebabToCamel,
+  objCamelToSnake,
+  objSnakeToCamel,
+  snakeToCamel,
+} from '../caseConverters';
+
+describe('Case converters', () => {
+  it('Camel-Kebab', () => {
+    const camelStr = 'camelToKebab';
+    const kebabStr = 'camel-to-kebab';
+    expect(camelToKebab(camelStr)).toBe(kebabStr);
+    expect(kebabToCamel(kebabStr)).toBe(camelStr);
+  });
+
+  it('Camel-Snake', () => {
+    const camelStr = 'camelToSnake';
+    const snakeStr = 'camel_to_snake';
+    expect(camelToSnake(camelStr)).toBe(snakeStr);
+    expect(snakeToCamel(snakeStr)).toBe(camelStr);
+  });
+
+  it('Camel-Snake, test case 1: do not convert 1st uppercase letter', () => {
+    const camelStr = 'Timer';
+    const snakeStr = 'Timer';
+    expect(camelToSnake(camelStr)).toBe(snakeStr);
+    expect(snakeToCamel(snakeStr)).toBe(camelStr);
+  });
+
+  it('Camel <- Snake skips first char "_"', () => {
+    const camelStr = '_camelToSnake';
+    const snakeStr = '_camel_to_snake';
+    expect(snakeToCamel(snakeStr)).toBe(camelStr);
+  });
+
+  it('Camel-Snake Objects', () => {
+    const camelObj = { camelToSnake: { camelToSnake: null, arr: [10] } };
+    const snakeObj = { camel_to_snake: { camel_to_snake: null, arr: [10] } };
+    expect(objCamelToSnake(camelObj)).toEqual(snakeObj);
+    expect(objSnakeToCamel(snakeObj)).toEqual(camelObj);
+  });
+
+  it('Camel-Snake Objects: NULL VALUES', () => {
+    const camelObj = null;
+    const snakeObj = null;
+    expect(objCamelToSnake(camelObj)).toEqual(snakeObj);
+    expect(objSnakeToCamel(snakeObj)).toEqual(camelObj);
+  });
+
+  it('Camel-Snake Arrays', () => {
+    const camelArr = ['camelToSnake', { camelToSnake: { camelToSnake: null } }];
+    const snakeArr = ['camel_to_snake', { camel_to_snake: { camel_to_snake: null } }];
+    expect(objCamelToSnake(camelArr)).toEqual(snakeArr);
+    expect(objSnakeToCamel(snakeArr)).toEqual(camelArr);
+  });
+
+  it('Camel-to-Snake Object skips passed keys', () => {
+    const skippedKeys = ['skippedKey'];
+    const camelArr = { camelToSnake: null, skippedKey: null };
+    const snakeArr = { camel_to_snake: null, skippedKey: null };
+    expect(objCamelToSnake(camelArr, skippedKeys)).toEqual(snakeArr);
+  });
+
+  it('Snake-to-Camel Object skips passed keys', () => {
+    const skippedKeys = ['skipped_key'];
+    const camelArr = { camelToSnake: null, skipped_key: null };
+    const snakeArr = { camel_to_snake: null, skipped_key: null };
+    expect(objSnakeToCamel(snakeArr, skippedKeys)).toEqual(camelArr);
+  });
+});

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

@@ -0,0 +1,21 @@
+import convertDuration from '../convertDuration';
+
+describe('Case converters', () => {
+  it('duration from sec value', () => {
+    const time = 111;
+    const duration = '00:01:51';
+    expect(convertDuration(time)).toBe(duration);
+  });
+
+  it('duration from sec string value', () => {
+    const time = '61';
+    const duration = '00:01:01';
+    expect(convertDuration(time)).toBe(duration);
+  });
+
+  it('duration from false value', () => {
+    const time = null;
+    const duration = '00:00:00';
+    expect(convertDuration(time)).toBe(duration);
+  });
+});

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

@@ -0,0 +1,15 @@
+import debounce from '../debounce';
+
+describe('debounce', () => {
+  it('debounces call', async (done) => {
+    let isFnCalled = false;
+    let fn = () => { isFnCalled = true; };
+    fn = debounce(fn, 50);
+    fn();
+    expect(isFnCalled).toBeFalsy();
+    await setTimeout(() => {
+      expect(isFnCalled).toBeTruthy();
+      done();
+    }, 100);
+  });
+});

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

@@ -0,0 +1,9 @@
+import editProxy from '../editProxy';
+
+describe('editProxy', () => {
+  it('correctly updates _dirty prop at object property change', () => {
+    const object = editProxy({ value: 'jest', _dirty: false });
+    object.value = 'upd jest';
+    expect(object._dirty).toBe(true);
+  });
+});

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,77 @@
+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 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/dist/img/arrow-down--active--md.7b60f2fb6090366652124f77c543a516.svg

@@ -1,3 +0,0 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M11.5049 14.7841L7.20524 10.2583C6.93159 9.97038 6.93159 9.5036 7.20524 9.21584C7.47865 8.92805 7.9221 8.92805 8.19549 9.21584L12.0001 13.2205L15.8045 9.21595C16.078 8.92817 16.5214 8.92817 16.7949 9.21595C17.0684 9.50374 17.0684 9.97049 16.7949 10.2584L12.4951 14.7842C12.3583 14.9281 12.1792 15 12.0001 15C11.8209 15 11.6417 14.928 11.5049 14.7841Z" fill="black"/>
-</svg>