fix: build

packages/collection-utils/test/chunk.spec.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import {chunk} from '../src/chunk';
+import {expect} from "chai";
+
+describe('chunk', function () {
+  it('should chunk items in the correct sizes', function () {
+    expect(chunk([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3)).to.deep.equal([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]);
+  });
+});

packages/collection-utils/test/difference.spec.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {differenceBy} from '../src/difference';
+import {expect} from "chai";
+
+describe('differenceBy', function () {
+  it('should return the difference of two arrays', function () {
+    const a = [1, 2, 3, 4, 5];
+    const b = [1, 2, 3];
+
+    expect(differenceBy(a, b, it => it)).to.deep.equal([4, 5]);
+  });
+});

packages/collection-utils/test/get.spec.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {get} from '../src/get';
+import {expect} from "chai";
+
+describe('get', function () {
+  it('should get a simple path', function () {
+    const object = {
+      a: {
+        b: {
+          c: 'd',
+        },
+      },
+    };
+    expect(get(object, 'a.b.c')).to.equal('d');
+  });
+
+  it('should return undefined for a non-existent path', function () {
+    const object = {
+      a: {
+        b: {
+          c: 'd',
+        },
+      },
+    };
+    expect(get(object, 'a.b.c.d')).to.be.undefined;
+  });
+});

packages/collection-utils/test/group-by.spec.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {groupBy, groupByStable, groupByProperty} from '../src/group-by';
+import {expect} from "chai";
+
+describe('groupBy', () => {
+  it('should group an array by a key', () => {
+    const array = [
+      {id: 1, name: 'one'},
+      {id: 2, name: 'two'},
+      {id: 3, name: 'three'},
+      {id: 4, name: 'four'},
+      {id: 5, name: 'five'},
+    ];
+
+    const result = groupBy(array, it => it.name);
+
+    expect(result).to.deep.equal({
+      one: [{id: 1, name: 'one'}],
+      two: [{id: 2, name: 'two'}],
+      three: [{id: 3, name: 'three'}],
+      four: [{id: 4, name: 'four'}],
+      five: [{id: 5, name: 'five'}],
+    });
+  });
+
+  it('should handle multiple elements per group', () => {
+    const array = [
+      {id: 1, name: 'one'},
+      {id: 2, name: 'two'},
+      {id: 3, name: 'three'},
+      {id: 4, name: 'four'},
+      {id: 5, name: 'five'},
+      {id: 6, name: 'one'},
+      {id: 7, name: 'two'},
+      {id: 8, name: 'three'},
+      {id: 9, name: 'four'},
+      {id: 10, name: 'five'},
+    ];
+
+    const result = groupBy(array, it => it.name);
+
+    expect(result).to.deep.equal({
+      one: [
+        {id: 1, name: 'one'},
+        {id: 6, name: 'one'},
+      ],
+      two: [
+        {id: 2, name: 'two'},
+        {id: 7, name: 'two'},
+      ],
+      three: [
+        {id: 3, name: 'three'},
+        {id: 8, name: 'three'},
+      ],
+      four: [
+        {id: 4, name: 'four'},
+        {id: 9, name: 'four'},
+      ],
+      five: [
+        {id: 5, name: 'five'},
+        {id: 10, name: 'five'},
+      ],
+    });
+  });
+});
+
+describe('groupByStable', () => {
+  const array = [
+    {id: 2, name: 'two'},
+    {id: 4, name: 'three'},
+    {id: 3, name: 'three'},
+    {id: 1, name: 'one'},
+  ];
+  const result = groupByStable(array, it => it.name);
+
+  it('should group an array by keys', () => {
+    expect(result.get('one')).to.deep.equal([{id: 1, name: 'one'}]);
+    expect(result.get('two')).to.deep.equal([{id: 2, name: 'two'}]);
+    expect(result.get('three')).to.deep.equal([
+      {id: 4, name: 'three'},
+      {id: 3, name: 'three'},
+    ]);
+  });
+
+  it('should provide ordered keys', () => {
+    // eslint-disable-next-line unicorn/prefer-spread
+    expect(Array.from(result.keys())).to.deep.equal(['two', 'three', 'one']);
+  });
+});
+
+describe('groupByProperty', function () {
+  it('should group by property', () => {
+    const array = [
+      {id: 1, name: 'one'},
+      {id: 2, name: 'two'},
+      {id: 3, name: 'three'},
+      {id: 4, name: 'four'},
+      {id: 5, name: 'five'},
+    ];
+
+    const result = groupByProperty(array, 'name');
+
+    expect(result).to.deep.equal({
+      one: [{id: 1, name: 'one'}],
+      two: [{id: 2, name: 'two'}],
+      three: [{id: 3, name: 'three'}],
+      four: [{id: 4, name: 'four'}],
+      five: [{id: 5, name: 'five'}],
+    });
+  });
+});

packages/collection-utils/test/key-by.spec.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {keyBy} from '../src/key-by';
+import {expect} from "chai";
+
+describe('keyBy', function () {
+  it('should key objects', function () {
+    const objects = [
+      {
+        id: 1,
+        name: 'foo',
+      },
+      {
+        id: 2,
+        name: 'bar',
+      },
+    ];
+    const result = keyBy(objects, it => it.id);
+    expect(result).to.deep.equal({
+      1: {
+        id: 1,
+        name: 'foo',
+      },
+      2: {
+        id: 2,
+        name: 'bar',
+      },
+    });
+  });
+});

packages/collection-utils/test/map-values.spec.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {mapValues} from '../src/map-values';
+import {expect} from "chai";
+
+describe('map-values', () => {
+  it('should map values', () => {
+    const object = {
+      a: 1,
+      b: 2,
+      c: 3,
+    };
+
+    const result = mapValues(object, value => value * 2);
+
+    expect(result).to.deep.equal({
+      a: 2,
+      b: 4,
+      c: 6,
+    });
+  });
+
+  it('should not modify the original object', () => {
+    const object = {
+      a: 1,
+      b: 2,
+      c: 3,
+    };
+
+    mapValues(object, value => value * 2);
+
+    expect(object).to.deep.equal({
+      a: 1,
+      b: 2,
+      c: 3,
+    });
+  });
+});

packages/collection-utils/test/min.spec.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {minBy} from '../src/min';
+import {expect} from "chai";
+
+describe('minBy', function () {
+  it('should pick the minimum value based on transform', function () {
+    expect(
+      minBy(
+        [
+          {id: 1, name: 'A'},
+          {id: 2, name: 'B'},
+          {id: 3, name: 'C'},
+        ],
+        it => it.id,
+      ),
+    ).to.deep.equal({id: 1, name: 'A'});
+  });
+
+  it('should not return undefined if there are other choices', function () {
+    expect(
+      minBy(
+        [
+          {id: undefined, name: 'B'},
+          {id: 1, name: 'A'},
+          {id: undefined, name: 'C'},
+        ],
+        it => it.id,
+      ),
+    ).to.deep.equal({id: 1, name: 'A'});
+  });
+});

packages/collection-utils/test/omit.spec.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {omit} from '../src/omit';
+import {expect} from "chai";
+
+describe('omit', function () {
+  it('should omit keys', function () {
+    const object = {a: 1, b: 2, c: 3};
+    const result = omit(object, 'a', 'c');
+    expect(result).to.deep.equal({b: 2});
+  });
+});

packages/collection-utils/test/partition.spec.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {partition} from '../src/partition';
+import {expect} from "chai";
+
+describe('partition', function () {
+  it('should partition an array', function () {
+    expect(partition([1, 2, 3, 4], it => it % 2 === 0)).to.deep.equal([
+      [2, 4],
+      [1, 3],
+    ]);
+  });
+});

packages/collection-utils/test/pick.spec.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {pick} from '../src/pick';
+import {expect} from "chai";
+
+describe('pick', function () {
+  it('should pick properties', function () {
+    const object = {a: 1, b: 2, c: 3};
+    const result = pick(object, ['a', 'c']);
+    expect(result).to.deep.equal({a: 1, c: 3});
+  });
+});

packages/collection-utils/test/shuffle.spec.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {shuffle} from '../src/shuffle';
+import {expect} from "chai";
+
+describe('shuffle', function () {
+  it('should shuffle an array', function () {
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    const shuffled = shuffle(array);
+    expect(shuffled).not.to.deep.equal(array);
+    expect(shuffled).to.contain.members(array);
+  });
+
+  it('should not modify the original array', function () {
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    shuffle(array);
+    expect(array).to.deep.equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+});

packages/collection-utils/test/string-sort.spec.ts

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {stringSort, stringSortBy} from '../src/string-sort';
+import {expect} from "chai";
+
+describe('stringSort', () => {
+  it('should sort an array of strings', () => {
+    expect(['a', 'c', 'b', 'd'].sort(stringSort)).to.deep.equal(['a', 'b', 'c', 'd']);
+  });
+});
+
+describe('stringSortBy', () => {
+  it('should sort an array of strings', () => {
+    expect([{item: 'a'}, {item: 'c'}, {item: 'b'}, {item: 'd'}].sort(stringSortBy(it => it.item))).to.deep.equal([
+      {item: 'a'},
+      {item: 'b'},
+      {item: 'c'},
+      {item: 'd'},
+    ]);
+  });
+});

packages/collection-utils/test/sum.spec.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expect} from "chai";
+import {sum, sumBy} from '../src/sum';
+
+describe('sum', () => {
+  it('should return the sum of all elements in the collection', () => {
+    const collection = [1, 2, 3, 4, 5];
+    const result = sum(collection);
+    expect(result).to.equal(15);
+  });
+});
+
+describe('sumBy', function () {
+  it('should return the sum of all elements in the collection', () => {
+    const collection = [{a: 1}, {a: 2}, {a: 3}, {a: 4}, {a: 5}];
+    const result = sumBy(collection, it => it.a);
+    expect(result).to.equal(15);
+  });
+});

packages/collection-utils/test/tree-group.spec.ts

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expect} from "chai";
+import {Tree, treeGroupBy} from '../src/tree-group';
+
+interface TestItem {
+  id: number;
+  path?: string[];
+}
+
+describe('tree-group', function () {
+  it('should create a tree', function () {
+    const items: Array<TestItem> = [
+      {
+        id: 1,
+        path: ['a', 'b', 'c'],
+      },
+      {
+        id: 2,
+        path: ['a', 'b', 'd'],
+      },
+    ];
+
+    const tree = treeGroupBy(items, item => item.path ?? []);
+
+    const expectedTree: Tree<TestItem> = {
+      a: {
+        b: {
+          c: {_: [items[0]]},
+          d: {_: [items[1]]},
+        } as Tree<TestItem>,
+      } as Tree<TestItem>,
+    } as Tree<TestItem>;
+
+    expect(tree).to.deep.equal(expectedTree);
+  });
+
+  it('should also sort empty paths', () => {
+    const items: Array<TestItem> = [
+      {
+        id: 1,
+        path: ['a', 'b', 'c'],
+      },
+      {
+        id: 2,
+      },
+    ];
+
+    const tree = treeGroupBy(items, item => item.path ?? []);
+
+    const expectedTree: Tree<TestItem> = {
+      a: {
+        b: {
+          c: {_: [items[0]]},
+        } as Tree<TestItem>,
+      } as Tree<TestItem>,
+      _: [items[1]],
+    } as Tree<TestItem>;
+
+    expect(tree).to.deep.equal(expectedTree);
+  });
+});

packages/collection-utils/test/uniq.spec.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expect} from "chai";
+import {uniqBy} from '../src/uniq';
+
+describe('uniq', function () {
+  it('should return an array with unique values', function () {
+    const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    const result = uniqBy(array, it => it);
+    expect(result).to.deep.equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+});

packages/collection-utils/test/zip.spec.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expect} from "chai";
+import {zip} from '../src/zip';
+
+describe('zip', function () {
+  it('should zip arrays together', function () {
+    expect(zip([1, 2, 3], [4, 5, 6])).to.deep.equal([
+      [1, 4],
+      [2, 5],
+      [3, 6],
+    ]);
+  });
+});