Overview #

[Pub]

Some help functions for using Lists

Whats MS_List_Utils do #

Add useful functions to map:

• addAround Returns new list with items generated around list.
• addBetween Returns new list with items generated between list.
• firstOrNull Returns first element in array, if it's empty returns null.
• firstWhereOrAdd
• isFirst creates an Map by using one array for keys and another for its values
• isLast put an item if absent or return existent value async.
• joinLast iterate all items in Map for reduce to a unique value returned from callback ReduceFunction .
• lastOrNull Returns last element in array, if it's empty returns null.
• lastWhereOrAdd remove all entries that contains a key in list.
• toMap trim all Strings in a map it's recursive.
• toStream trim all Strings in a map it's recursive.

Usage #

Just import lib and use extensions, call the functions to starts work:

// Don't forget to import
import 'package:ms_list_utils/ms_list_utils.dart';

Map itsAMap = {'key1' : null, 'key2' : 'just a String'};
compact(itsAMap); // Output: {'key2':'just a String'}
// or using extensions.
itsAMap.compact(); // Output: {'key2':'just a String'}

compact #

The function compact remove all MapEntries that's values is null it's recursive.

test('Must return a new empty HashMap without null values', () {
    var mapWithNullValues = {
      'k1': null,
      'k2': null,
      'k3': null,
      'map': {
        'k1': null,
        'k2': null,
        'k3': null,
      },
      'list': [
        {
          'k1': null,
          'k2': null,
          'k3': null,
        },
        {
          'k1': null,
          'k2': null,
          'k3': null,
        },
      ]
    };
    var mapWithoutNull = compact(mapWithNullValues);
    expect(mapWithoutNull, {
      'map': {},
      'list': [{}, {}]
    });
  });

see more in test file.

containsKeys #

The function containsKeys check if map contains all keys of list.

  test('Must return true if contains a list of keys', () {
    var listOfKeyToCheck = ['key1', 'key2'];
    var mapToCheck = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'};
    expect(mapToCheck.containsKeys(listOfKeyToCheck), isTrue);
  });

see more in test file.

diff #

The function diff returns a new map contend only difference between maps

  test(
      'must return a new map with differences in values with differences is in nested map',
      () {
    var fromMap = {
      'key1': 'value1',
      'nestedMap': {'key2': 'value2', 'key3': 'value3'},
      'otherNestedMap': {'randomKey': []}
    };
    var toMap = {
      'key1': 'value1',
      'nestedMap': {'key2': 123, 'key3': 'value3'},
      'otherNestedMap': 'random value'
    };
    expect(diff(fromMap, toMap), {
      'nestedMap': {'key2': 123},
      'otherNestedMap': 'random value'
    });
  });

see more in test file.

doIfContains #

The function doIfContains will be call a callback function if the map contains a key ou else it will be a callback function elseIf if elseIf is null, null will return.

  test('must return a object if contains a key', () {
    final testMap = {'key1': 'value1', 'key2': 'value2'};
    final newThing = doIfContains<List<String>>(testMap, 'key2',
        doWork: (key, value) =>
            [value.toString(), 'new awesome thing', key.toString()],
        elseIf: () => ['nothing']);
    expect(newThing, ['value2', 'new awesome thing', 'key2']);
  });

see more in test file.

listCombine #

The function listCombine creates an Map by using one array for keys and another for its values.

  test('combine two list as map', () {
    final keys = ['red', 'green', 'blue', 'white', 'black'];
    final values = [0xFF0000, 0x00FF00, 0x0000FF, 0xFFFFFF, 0x000000];
    final newMap = listCombine<String, int>(keys, values);
    expect(newMap is Map<String, int>, isTrue);
    expect({
      'red': 0xFF0000,
      'green': 0x00FF00,
      'blue': 0x0000FF,
      'white': 0xFFFFFF,
      'black': 0x000000,
    }, newMap);
  });

see more in test file.

putIfAbsentAsync #

The function putIfAbsentAsync put an item if absent or return existent value async.

  test('Call async function for empty map', () async {
    var emptyMap = <String, String>{};
    expect(emptyMap.containsKey('test'), isFalse);
    var item = await emptyMap.putIfAbsentAsync('test', () async {
      await Future.delayed(Duration(milliseconds: 1500));
      return 'Random String';
    });
    expect(emptyMap, isNotEmpty);
    expect(emptyMap.containsKey('test'), isTrue);
    expect(item, 'Random String');
  });

see more in test file.

reduce #

The function reduce iterate all items in Map for reduce to a unique value returned from callback ReduceFunction .

  test('Multiplies all int values to 120', () {
    Map mapNumbers = <String, int>{
      'key1': 1,
      'key2': 2,
      'key3': 3,
      'key4': 4,
      'key5': 5,
    };
    var value = mapNumbers
        .reduce<int>((int acc, _, value) => (acc ?? 1) * (value as int));
    expect(value, 120, reason: 'Value reduced must be 120');
  });

see more in test file.

removeKeys #

The function removeKeys remove all entries that contains a key in list.

  test('Remove all entries that has a key in list with recursive', () {
    Map mapNumbers = {
      'key1': 1,
      'key2': 2,
      'key3': 3,
      'key4': 4,
      'key5': 5,
      'map': {
        'key1': 1,
        'key2': 2,
        'key3': 3,
        'key4': 4,
        'key5': 5,
      }
    };
    mapNumbers.removeKeys(['key1', 'key2'], true);
    expect(mapNumbers.length, 4);
    expect(mapNumbers['map'].length, 3);
  });

see more in test file.

removeKeysExcept #

The function removeKeysExcept remove all entries that NOT contains a key in list.

  test('Remove all entries that has a key NOT in list with recursive', () {
    Map mapNumbers = {
      'key1': 1,
      'key2': 2,
      'key3': 3,
      'key4': 4,
      'key5': 5,
      'map': {
        'key1': 1,
        'key2': 2,
        'key3': 3,
        'key4': 4,
        'key5': 5,
      }
    };
    mapNumbers.removeKeysExcept(['key1', 'key2', 'map'], true);
    expect(mapNumbers.length, 3);
    expect(mapNumbers['map'].length, 2);
  });

see more in test file.

trim #

The function trim all Strings in a map it's recursive.

    test('Most trim any Strings values', () {
      const mapToTrim = {
        'key1': '  random string    ',
        'key2': '       another random string       ',
        'key3': 321
      };
      expect(mapToTrim.trim(true), {
        'key1': 'random string',
        'key2': 'another random string',
        'key3': 321
      });
    });

see more in test file.

See another libs here