@webitel/ui-sdk 0.1.1 → 0.1.2-vite

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

@@ -0,0 +1,153 @@
+import userinfo from '../api/userinfo';
+import ApplicationsAccess from '../classes/ApplicationsAccess';
+import BaseStoreModule from '../../../store/BaseStoreModules/BaseStoreModule';
+import Permissions from '../enums/Permissions.enum';
+
+const defaultState = () => ({
+  isLoading: true,
+  domainId: 0,
+  name: '',
+  username: '',
+  account: '',
+  preferredUsername: '',
+  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;
+    },
+    GET_OBJECT_SCOPE: (state, getters) => ({ name, route }) => {
+      if (route) return getters.GET_OBJECT_SCOPE_BY_ROUTE(route);
+      return getters.GET_OBJECT_SCOPE_BY_NAME(name);
+    },
+    GET_OBJECT_SCOPE_BY_NAME: (state) => (name) => (
+      Object.values(state.scope).find((object) => name === object.name)
+    ),
+    GET_OBJECT_SCOPE_BY_ROUTE: (state) => (route) => (
+      Object.values(state.scope).find((object) => route.name.includes(object.route))
+    ),
+    HAS_READ_ACCESS: (state, getters) => (checkedObject) => {
+      if (!getters.CHECK_OBJECT_ACCESS(checkedObject)) return false;
+      if (state.permissions[Permissions.READ]) return true;
+      const objectScope = getters.GET_OBJECT_SCOPE(checkedObject);
+      return objectScope?.access?.includes('r');
+    },
+    HAS_CREATE_ACCESS: (state, getters) => (checkedObject) => {
+      if (state.permissions[Permissions.CREATE]) return true;
+      const objectScope = getters.GET_OBJECT_SCOPE(checkedObject);
+      return objectScope?.access?.includes('x');
+    },
+    HAS_EDIT_ACCESS: (state, getters) => (checkedObject) => {
+      if (state.permissions[Permissions.EDIT]) return true;
+      const objectScope = getters.GET_OBJECT_SCOPE(checkedObject);
+      return objectScope?.access?.includes('w');
+    },
+    HAS_DELETE_ACCESS: (state, getters) => (checkedObject) => {
+      if (state.permissions[Permissions.DELETE]) return true;
+      const objectScope = getters.GET_OBJECT_SCOPE(checkedObject);
+      return objectScope?.access?.includes('d');
+    },
+  }
+
+  actions = {
+    BEFORE_OPEN_SESSION_HOOK: () => {},
+    AFTER_OPEN_SESSION_HOOK: () => {},
+    CONVERT_USER_SCOPE: (context, scope) => scope,
+    CONVERT_USER_PERMISSIONS: (context, initialPermissions) => {
+      let permissions = {};
+      if (!initialPermissions) return permissions;
+      permissions = initialPermissions.reduce((permissions, currentPermission) => ({
+        ...permissions,
+        [currentPermission.id]: currentPermission,
+      }), {});
+      return 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/plugins/breakpoint/breakpoint.plugin.js

@@ -0,0 +1,137 @@
+import { reactive } from 'vue';
+import debounce from '../../scripts/debounce';
+
+// https://stackoverflow.com/questions/41791193/vuejs-reactive-binding-for-a-plugin-how-to/41801107#41801107
+// https://stackoverflow.com/questions/50111231/vue-prototype-not-reactive-when-data-changes
+
+// https://github.com/vuetifyjs/vuetify/blob/master/packages/vuetify/src/services/breakpoint/index.ts
+
+const breakpoint = reactive({
+  // Breakpoints
+  xs: false,
+  sm: false,
+  md: false,
+  lg: false,
+  xl: false,
+
+  // Conditionals
+  xsOnly: false,
+  smOnly: false,
+  smAndDown: false,
+  smAndUp: false,
+  mdOnly: false,
+  mdAndDown: false,
+  mdAndUp: false,
+  lgOnly: false,
+  lgAndDown: false,
+  lgAndUp: false,
+  xlOnly: false,
+
+  // true if screen width < mobileBreakpoint
+  mobile: true,
+
+  // Current breakpoint name (e.g. 'md')
+  name: 'xs',
+  // Dimensions
+  height: 0,
+  width: 0,
+});
+
+const getClientWidth = () => Math.max(
+  document.documentElement.clientWidth,
+  window.innerWidth || 0,
+);
+
+const getClientHeight = () => Math.max(
+  document.documentElement.clientHeight,
+  window.innerHeight || 0,
+);
+
+const thresholds = {
+  xs: 600,
+  sm: 960,
+  md: 1264,
+  lg: 1904,
+};
+const mobileBreakpoint = 'sm';
+const scrollBarWidth = 16;
+
+const onResize = () => {
+  const height = getClientHeight();
+  const width = getClientWidth();
+
+  const xs = width < thresholds.xs;
+  const sm = width < thresholds.sm && !xs;
+  const md = width < (thresholds.md - scrollBarWidth) && !(sm || xs);
+  const lg = width < (thresholds.lg - scrollBarWidth) && !(md || sm || xs);
+  const xl = width >= (thresholds.lg - scrollBarWidth);
+
+  breakpoint.height = height;
+  breakpoint.width = width;
+
+  breakpoint.xs = xs;
+  breakpoint.sm = sm;
+  breakpoint.md = md;
+  breakpoint.lg = lg;
+  breakpoint.xl = xl;
+
+  breakpoint.xsOnly = xs;
+  breakpoint.smOnly = sm;
+  breakpoint.smAndDown = (xs || sm) && !(md || lg || xl);
+  breakpoint.smAndUp = !xs && (sm || md || lg || xl);
+  breakpoint.mdOnly = md;
+  breakpoint.mdAndDown = (xs || sm || md) && !(lg || xl);
+  breakpoint.mdAndUp = !(xs || sm) && (md || lg || xl);
+  breakpoint.lgOnly = lg;
+  breakpoint.lgAndDown = (xs || sm || md || lg) && !xl;
+  breakpoint.lgAndUp = !(xs || sm || md) && (lg || xl);
+  breakpoint.xlOnly = xl;
+
+  switch (true) {
+    case (xs):
+      breakpoint.name = 'xs';
+      break;
+    case (sm):
+      breakpoint.name = 'sm';
+      break;
+    case (md):
+      breakpoint.name = 'md';
+      break;
+    case (lg):
+      breakpoint.name = 'lg';
+      break;
+    default:
+      breakpoint.name = 'xl';
+      break;
+  }
+
+  if (typeof mobileBreakpoint === 'number') {
+    breakpoint.mobile = width < parseInt(mobileBreakpoint, 10);
+
+    return;
+  }
+
+  const breakpoints = {
+    xs: 0,
+    sm: 1,
+    md: 2,
+    lg: 3,
+    xl: 4,
+  };
+
+  const current = breakpoints[breakpoint.name];
+  const max = breakpoints[mobileBreakpoint];
+
+  breakpoint.mobile = current <= max;
+};
+
+const install = (app) => {
+  window.addEventListener('resize', debounce(onResize), { passive: true });
+
+  onResize();
+
+  // eslint-disable-next-line no-param-reassign
+  app.config.globalProperties.$breakpoint = breakpoint;
+};
+
+export { install };

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

@@ -0,0 +1,81 @@
+import {
+  camelToKebab,
+  camelToSnake,
+  kebabToCamel,
+  snakeToKebab,
+  kebabToSnake,
+  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('Snake-Kebab', () => {
+    const snakeStr = 'snake_to_kebab';
+    const kebabStr = 'snake-to-kebab';
+    expect(snakeToKebab(snakeStr)).toBe(kebabStr);
+    expect(kebabToSnake(kebabStr)).toBe(snakeStr);
+  });
+
+  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,14 @@
+import debounce from '../debounce';
+
+describe('debounce', () => {
+  it('debounces call', async () => {
+    let isFnCalled = false;
+    let fn = () => { isFnCalled = true; };
+    fn = debounce(fn, 50);
+    fn();
+    expect(isFnCalled).toBeFalsy();
+    await setTimeout(() => {
+      expect(isFnCalled).toBeTruthy();
+    }, 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/__tests__/updateObject.spec.js

@@ -0,0 +1,19 @@
+import updateObject from '../updateObject';
+
+describe('updateObject', () => {
+  it('doesn\'t mutate original object', () => {
+    const original = { jest: 'jest' };
+    updateObject({ obj: original, path: 'jest', value: '123' });
+    expect(original.jest).toBe('jest');
+  });
+  it('changes shallow value', () => {
+    const original = { jest: 'jest' };
+    const result = { jest: 'huest' };
+    expect(updateObject({ obj: original, path: 'jest', value: 'huest' })).toEqual(result);
+  });
+  it('changes deep value', () => {
+    const original = { jest: { deep: 'jest' } };
+    const result = { jest: { deep: 'huest' } };
+    expect(updateObject({ obj: original, path: 'jest.deep', value: 'huest' })).toEqual(result);
+  });
+});

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 !== undefined && 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 !== undefined && 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/debounce.js

@@ -1,11 +1,5 @@
-const debounce = (method, delay = 1000) => {
-  let timer;
-  return (args) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      method(args);
-    }, delay);
-  };
-};
+import lodashDebounce from 'lodash/debounce';
+
+const debounce = (fn, wait = 1000, options) => lodashDebounce(fn, wait, options);
 
 export default debounce;

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,8 @@
+import emitter from 'tiny-emitter/instance';
+
+export default {
+  $on: (...args) => emitter.on(...args),
+  $once: (...args) => emitter.once(...args),
+  $off: (...args) => emitter.off(...args),
+  $emit: (...args) => emitter.emit(...args),
+};

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;