How to use

isArray

function

in

lodash

export function serializePropertyValue(value) {

  if (isArray(value))
    return value.map(sub => serializePropertyValue(sub));

  if (isObject(value) && Reflect.has(value, `serialize`))
    return value.serialize();

  return value;

}

describe('fn: getCategoriesList', () => {
 const categoriesList = CategoryController.getCategoriesList();

 it('should return an array', () => {
  expect(isArray(categoriesList)).toBeTruthy();
 });

 it('should return a full list', () => {
  expect(categoriesList.length).toBe(4);
 });
});

const customizer = (objValue, srcValue, key, object, source, stack) => {
 if (stack.size === 2) {
  // will not merge array
  if (isArray(srcValue)) {
   return srcValue;
  }
 }
}

function deleteFeedSubscriptions (req, res, next) {
 if (!isArray(req.body) || req.body.length === 0) {
  return next({httpStatus: 400, message: 'no ids provided in the body'})
 }
 const repo = new ClientFeedSubcriptionRepository(req.database)
 const ids = req.body.map(ObjectId)
 return repo.deleteByClientIds(ids)
  .then(function () {
   next()
  })
  .catch(next)
}

// Recursive merge with array concatenation
const mergeDeep = (a, b) =>
  mergeWith({}, a, b, (c, d) =>
    (isArray(c) && isArray(d))
      ? c.concat(d)
      : undefined
  )

function customizer(objValue, srcValue) {
 if (isArray(objValue)) {
  return objValue.concat(srcValue)
 }
 return undefined
}

function createHumps(keyConverter) {
 return function humps(node) {
  if (isArray(node)) return map(node, humps);
  if (isPlainObject(node))
   return transform(node, createIteratee(keyConverter, humps));
  return node;
 };
}

/**
 *
 * @param {Function[]|*} mwList
 * @returns {boolean}
 */
const isValidMiddlewareList = mwList => {
 return every([
  isArray(mwList),
  every(mwList, isFunction),
 ], Boolean);
}

const convertFromDatabase = (entity) => {
 if (isArray(entity)) {
  return entity.map(convertFromDatabase)
 } else if (entity) {
  const ret = omit(entity, '_id')
  ret.id = entity._id
  return ret
 }
 return null
}

const notMergeArray = (objValue, srcValue, key, object, source, stack) => {
 if (isArray(srcValue)) {
  return srcValue;
 }
}

const notMergeArray = (objValue, srcValue, key, object, source, stack) => {
 if (isArray(srcValue)) {
  return srcValue;
 }
}

function createHumps(keyConverter) {
 return function humps(node) {
  if (isArray(node)) return map(node, humps);
  if (isPlainObject(node))
   return transform(node, createIteratee(keyConverter, humps));
  return node;
 };
}

const customizer = (objValue, srcValue, key, object, source, stack) => {
 if (stack.size === 2) {
  // will not merge array
  if (isArray(srcValue)) {
   return srcValue;
  }
 }
}

function createHumps(keyConverter) {
 return function humps(node) {
  if (isArray(node)) return map(node, humps);
  if (isPlainObject(node))
   return transform(node, createIteratee(keyConverter, humps));
  return node;
 };
}

/**
 * Converts a value to array or returns it if it is an Array
 * @param value
 * @returns {*[]}
 */
function toArray(value) {
 return isArray(value) ? value : [value];
}