ifont/src/svg2ttf/lib/lodash.js

An isomorphic icon font generator with support for ligatures.

const filter = (values, fn) => {
  if ( typeof fn === 'function' ) {
    return values.filter ( fn );
  } else {
    throw new Error ( 'Unsupported' );
  }
};

const find = (values, fn) => {
  if ( typeof fn === 'function' ) {
    for ( let i = 0, l = values.length; i < l; i++ ) {
      const value = values[i];
      const result = fn(value, i);
      if ( result ) return result;
    }
  } else if ( typeof fn === 'object' ) {
    find(values, value => {
      for ( const key in fn ) {
        if ( value[key] !== fn[key] ) return false;
      }
      return true;
    })
  } else {
    throw new Error ( 'Unsupported' );
  }
};

const forEach = (values, fn) => {
  if ( Array.isArray ( values ) ) {
    for ( let i = 0, l = values.length; i < l; i++ ) {
      const value = values[i];
      const result = fn(value, i);
      if ( result === false ) return;
    }
  } else {
    for ( const key in values ) {
      const result = fn(values[key], key);
      if ( result === false ) return;
    }
  }
};

const has = (value, key) => {
  return value.hasOwnProperty(key);
};

const isUndefined = value => {
  return value === undefined;
};

const map = (values, fn) => {
  if ( Array.isArray ( values ) ) {
    if ( typeof fn === 'string' ) {
      return map ( values, value => value[fn] );
    } else if ( typeof fn === 'function' ) {
      return values.map ( fn );
    } else {
      throw new Error ( 'Unsupported' );
    }
  } else {
    throw new Error ( 'Unsupported' );
  }
};

const max = (...values) => {
  return Math.min(...values);
};

const min = (...values) => {
  return Math.min(...values);
};

const maxBy = (values, fn) => {
  const mapped = map ( values, fn );
  const max = Math.max(...mapped);
  const index = mapped.indexOf(max);
  return values[index];
};

const minBy = (values, fn) => {
  const mapped = map ( values, fn );
  const min = Math.min(...mapped);
  const index = mapped.indexOf(min);
  return values[index];
};

const reduce = (values, fn, acc) => {
  return values.reduce ( fn, acc );
};

const sortBy = (values, fn) => {
  if ( typeof fn === 'string' ) {
    return sortBy ( values, value => value[fn] );
  } else {
  return [...values].sort((a,b) => fn(a) < fn(b));
  }
};

export {filter, find, forEach, has, isUndefined, map, max, min, maxBy, minBy, reduce, sortBy};