@nymphjs/sorter 1.0.0-beta.12 → 1.0.0-beta.121

package/dist/Sorter.js

@@ -0,0 +1,216 @@
+/**
+ * Entity Array Sorter
+ *
+ * Sorting functions sort the array in place and also return the sorted array.
+ */
+export default class Sorter {
+    array;
+    sortProperty = null;
+    sortParent = null;
+    collator = new Intl.Collator();
+    comparator = undefined;
+    identiticalResolver = (a, b) => 0;
+    constructor(array) {
+        this.array = array;
+    }
+    _arraySortProperty(a, b) {
+        const prop = this.sortProperty;
+        const parent = this.sortParent;
+        if (parent != null &&
+            a[parent] instanceof Object &&
+            b[parent] instanceof Object) {
+            const aParentProp = a[parent][prop];
+            const bParentProp = b[parent][prop];
+            if (typeof aParentProp !== 'undefined' ||
+                typeof bParentProp !== 'undefined') {
+                if (this.comparator != null) {
+                    const result = this.comparator(aParentProp, bParentProp);
+                    if (result !== 0) {
+                        return result;
+                    }
+                }
+                else if (typeof aParentProp === 'string' &&
+                    typeof bParentProp === 'string') {
+                    const result = this.collator.compare(aParentProp, bParentProp);
+                    if (result !== 0) {
+                        return result;
+                    }
+                }
+                else if (aParentProp > bParentProp) {
+                    return 1;
+                }
+                else if (aParentProp < bParentProp) {
+                    return -1;
+                }
+            }
+        }
+        // If they have the same parent, order them by their own prop.
+        const aProp = a[prop];
+        const bProp = b[prop];
+        if (this.comparator != null) {
+            const result = this.comparator(aProp, bProp);
+            if (result === 0) {
+                return this.identiticalResolver(a, b);
+            }
+            else {
+                return result;
+            }
+        }
+        else if (typeof aProp === 'string' && typeof bProp === 'string') {
+            const result = this.collator.compare(aProp, bProp);
+            if (result === 0) {
+                return this.identiticalResolver(a, b);
+            }
+            else {
+                return result;
+            }
+        }
+        else if (aProp > bProp) {
+            return 1;
+        }
+        else if (aProp < bProp) {
+            return -1;
+        }
+        else {
+            return this.identiticalResolver(a, b);
+        }
+    }
+    /**
+     * Sort an array of entities hierarchically by a specified property's value.
+     *
+     * Entities will be placed immediately after their parents. The
+     * `parentProperty` property, if present, should hold either null, undefined,
+     * or the entity's parent.
+     *
+     * @param property The name of the property to sort entities by.
+     * @param parentProperty The name of the property which holds the parent of the entity.
+     */
+    hsort(property, parentProperty, { caseSensitive = false, reverse = false, collatorOptions = undefined, comparator = undefined, identiticalResolver = (a, b) => 0, } = {}) {
+        if (typeof parentProperty === 'undefined' || parentProperty === null) {
+            // Just sort by the requested property.
+            this.sort(property, {
+                caseSensitive,
+                reverse,
+                collatorOptions,
+                comparator,
+            });
+            return this.array;
+        }
+        this.sortProperty = property;
+        this.sortParent = null;
+        this.collator = new Intl.Collator(undefined, collatorOptions || {
+            sensitivity: caseSensitive ? 'case' : 'base',
+        });
+        this.comparator = comparator;
+        this.identiticalResolver = identiticalResolver;
+        const sort = (array) => {
+            // Sort by the requested property.
+            array.sort(this._arraySortProperty.bind(this));
+            if (reverse) {
+                array.reverse();
+            }
+            return array;
+        };
+        // Pick out all of the children.
+        const guidEntries = {};
+        const newEntries = new Map();
+        // There is no incrementor in this for loop on purpose. It is incremented
+        // conditionally.
+        for (let i = 0; i < this.array.length;) {
+            const entity = this.array[i];
+            const parent = entity[parentProperty];
+            if (parent == null) {
+                i++;
+            }
+            else if (parent.guid != null) {
+                this.array.splice(i, 1);
+                if (!(parent.guid in guidEntries)) {
+                    guidEntries[parent.guid] = [];
+                }
+                guidEntries[parent.guid].push(entity);
+            }
+            else {
+                this.array.splice(i, 1);
+                let entries = [];
+                if (newEntries.has(parent)) {
+                    entries = newEntries.get(parent) || [];
+                }
+                entries.push(entity);
+                newEntries.set(parent, entries);
+            }
+        }
+        // Sort the top level entries.
+        sort(this.array);
+        // Now place all of the children back in order.
+        for (let i = 0; i < this.array.length; i++) {
+            const entity = this.array[i];
+            if (entity.guid != null) {
+                if (entity.guid in guidEntries) {
+                    this.array.splice(i + 1, 0, ...sort(guidEntries[entity.guid]));
+                    delete guidEntries[entity.guid];
+                }
+            }
+            else {
+                if (newEntries.has(entity)) {
+                    this.array.splice(i + 1, 0, ...sort(newEntries.get(entity.guid) || []));
+                    newEntries.delete(entity);
+                }
+            }
+        }
+        // Now place any orphans on the end.
+        for (let orphans of Object.values(guidEntries)) {
+            this.array.splice(this.array.length, 0, ...sort(orphans));
+        }
+        for (let [parent, orphans] of newEntries) {
+            this.array.splice(this.array.length, 0, ...sort(orphans));
+        }
+        return this.array;
+    }
+    /**
+     * Sort an array of entities by parent and a specified property's value.
+     *
+     * Entities' will be sorted by their parents' properties, then the entities'
+     * properties.
+     *
+     * @param property The name of the property to sort entities by.
+     * @param parentProperty The name of the property which holds the parent of the entity.
+     */
+    psort(property, parentProperty, { caseSensitive = false, reverse = false, collatorOptions = undefined, comparator = undefined, identiticalResolver = (a, b) => 0, } = {}) {
+        // Sort by the requested property.
+        this.sortProperty = property;
+        this.sortParent = parentProperty;
+        this.collator = new Intl.Collator(undefined, collatorOptions || {
+            sensitivity: caseSensitive ? 'case' : 'base',
+            caseFirst: 'false',
+        });
+        this.comparator = comparator;
+        this.identiticalResolver = identiticalResolver;
+        this.array.sort(this._arraySortProperty.bind(this));
+        if (reverse) {
+            this.array.reverse();
+        }
+        return this.array;
+    }
+    /**
+     * Sort an array of entities by a specified property's value.
+     *
+     * @param property The name of the property to sort entities by.
+     * @param identiticalResolver A function to resolve order of identical entities.
+     */
+    sort(property, { caseSensitive = false, reverse = false, collatorOptions = undefined, comparator = undefined, identiticalResolver = (a, b) => 0, } = {}) {
+        // Sort by the requested property.
+        this.sortProperty = property;
+        this.sortParent = null;
+        this.collator = new Intl.Collator(undefined, collatorOptions || {
+            sensitivity: caseSensitive ? 'case' : 'base',
+        });
+        this.comparator = comparator;
+        this.identiticalResolver = identiticalResolver;
+        this.array.sort(this._arraySortProperty.bind(this));
+        if (reverse) {
+            this.array.reverse();
+        }
+        return this.array;
+    }
+}
+//# sourceMappingURL=Sorter.js.map

package/dist/Sorter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sorter.js","sourceRoot":"","sources":["../src/Sorter.ts"],"names":[],"mappings":"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"}

package/dist/Sorter.test.js

@@ -0,0 +1,435 @@
+import Sorter from './Sorter.js';
+import { TestModel } from './testArtifacts.js';
+describe('Sorter', () => {
+    it('sorts entities by a string property', () => {
+        const entities = [];
+        for (const prop of ['d', 'a', 'C', 'e', 'b']) {
+            const entity = new TestModel();
+            entity.name = prop;
+            entities.push(entity);
+        }
+        const sorter = new Sorter(entities);
+        sorter.sort('name');
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'a',
+            'b',
+            'C',
+            'd',
+            'e',
+        ]);
+        sorter.sort('name', { reverse: true });
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'e',
+            'd',
+            'C',
+            'b',
+            'a',
+        ]);
+    });
+    it('sorts entities by a number property', () => {
+        const entities = [];
+        for (const prop of [4, 300, 5, 1, 2]) {
+            const entity = new TestModel();
+            entity.number = prop;
+            entities.push(entity);
+        }
+        const sorter = new Sorter(entities);
+        sorter.sort('number');
+        expect(sorter.array.map((entity) => entity.number)).toEqual([
+            1, 2, 4, 5, 300,
+        ]);
+        sorter.sort('number', { reverse: true });
+        expect(sorter.array.map((entity) => entity.number)).toEqual([
+            300, 5, 4, 2, 1,
+        ]);
+    });
+    it('sorts entities by a number property with an identical resolver', () => {
+        const entities = [];
+        for (const prop of [4, 300, 5, 1, 2]) {
+            const entity = new TestModel();
+            entity.number = 50;
+            entity.fallback = prop;
+            entities.push(entity);
+        }
+        const sorter = new Sorter(entities);
+        sorter.sort('number', {
+            identiticalResolver: (a, b) => (a.fallback || 0) - (b.fallback || 0),
+        });
+        expect(sorter.array.map((entity) => entity.fallback)).toEqual([
+            1, 2, 4, 5, 300,
+        ]);
+        sorter.sort('number', {
+            reverse: true,
+            identiticalResolver: (a, b) => (a.fallback || 0) - (b.fallback || 0),
+        });
+        expect(sorter.array.map((entity) => entity.fallback)).toEqual([
+            300, 5, 4, 2, 1,
+        ]);
+    });
+    it('sorts entities by a string property with an identical resolver', () => {
+        const entities = [];
+        for (const prop of [4, 300, 5, 1, 2]) {
+            const entity = new TestModel();
+            entity.name = 'John';
+            entity.fallback = prop;
+            entities.push(entity);
+        }
+        const sorter = new Sorter(entities);
+        sorter.sort('name', {
+            identiticalResolver: (a, b) => (a.fallback || 0) - (b.fallback || 0),
+        });
+        expect(sorter.array.map((entity) => entity.fallback)).toEqual([
+            1, 2, 4, 5, 300,
+        ]);
+        sorter.sort('name', {
+            reverse: true,
+            identiticalResolver: (a, b) => (a.fallback || 0) - (b.fallback || 0),
+        });
+        expect(sorter.array.map((entity) => entity.fallback)).toEqual([
+            300, 5, 4, 2, 1,
+        ]);
+    });
+    it('sorts entities case sensitively', () => {
+        const entities = [];
+        for (const prop of ['America', 'america', 'baseball', 'Bernard', 'zebra']) {
+            const entity = new TestModel();
+            entity.name = prop;
+            entities.push(entity);
+        }
+        const sorter = new Sorter(entities);
+        sorter.sort('name');
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'America',
+            'america',
+            'baseball',
+            'Bernard',
+            'zebra',
+        ]);
+        sorter.sort('name', { caseSensitive: true });
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'america',
+            'America',
+            'baseball',
+            'Bernard',
+            'zebra',
+        ]);
+        sorter.sort('name', {
+            collatorOptions: {
+                sensitivity: 'case',
+                caseFirst: 'upper',
+            },
+        });
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'America',
+            'america',
+            'baseball',
+            'Bernard',
+            'zebra',
+        ]);
+        sorter.sort('name', {
+            comparator: (a, b) => (a < b ? -1 : a > b ? 1 : 0),
+        });
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'America',
+            'Bernard',
+            'america',
+            'baseball',
+            'zebra',
+        ]);
+    });
+    it('sorts entities numerically', () => {
+        const entities = [];
+        for (const prop of [
+            '1: first',
+            '10: tenth',
+            '40: fourtieth',
+            '3: third',
+            '2: second',
+        ]) {
+            const entity = new TestModel();
+            entity.name = prop;
+            entities.push(entity);
+        }
+        const sorter = new Sorter(entities);
+        sorter.sort('name');
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            '1: first',
+            '10: tenth',
+            '2: second',
+            '3: third',
+            '40: fourtieth',
+        ]);
+        sorter.sort('name', {
+            collatorOptions: {
+                numeric: true,
+            },
+        });
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            '1: first',
+            '2: second',
+            '3: third',
+            '10: tenth',
+            '40: fourtieth',
+        ]);
+    });
+    it('sorts entities by parent', () => {
+        const firstParent = new TestModel();
+        firstParent.name = 'Aaron';
+        const secondParent = new TestModel();
+        secondParent.name = 'Kevin';
+        const entities = [
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Sarah';
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Jimmy';
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Mary';
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Jessica';
+                entity.parent = secondParent;
+                return entity;
+            })(),
+            firstParent,
+            secondParent,
+        ];
+        const sorter = new Sorter(entities);
+        sorter.psort('name', 'parent');
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'Aaron',
+            'Jimmy',
+            'Kevin',
+            'Mary',
+            'Sarah',
+            'Jessica',
+        ]);
+    });
+    it('sorts entities by parent with an identical resolver', () => {
+        const firstParent = new TestModel();
+        firstParent.name = 'Aaron';
+        firstParent.fallback = 1;
+        const secondParent = new TestModel();
+        secondParent.name = 'Kevin';
+        secondParent.fallback = 2;
+        const entities = [
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Steve';
+                entity.fallback = 3;
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Steve';
+                entity.fallback = 5;
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Steve';
+                entity.fallback = 4;
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Steve';
+                entity.fallback = 6;
+                entity.parent = secondParent;
+                return entity;
+            })(),
+            firstParent,
+            secondParent,
+        ];
+        const sorter = new Sorter(entities);
+        sorter.psort('name', 'parent', {
+            identiticalResolver: (a, b) => (a.fallback || 0) - (b.fallback || 0),
+        });
+        expect(sorter.array.map((entity) => entity.fallback)).toEqual([
+            1, 2, 3, 4, 5, 6,
+        ]);
+    });
+    it('sorts entities hierarchically', () => {
+        const getEntries = () => {
+            const firstParent = new TestModel();
+            firstParent.name = 'Herbert';
+            const secondParent = new TestModel();
+            secondParent.name = 'Anthony';
+            const subParent = new TestModel();
+            subParent.name = 'Lamar';
+            subParent.parent = secondParent;
+            return [
+                (() => {
+                    const entity = new TestModel();
+                    entity.name = 'Jacob';
+                    entity.parent = firstParent;
+                    return entity;
+                })(),
+                (() => {
+                    const entity = new TestModel();
+                    entity.name = 'Joshua';
+                    entity.parent = firstParent;
+                    return entity;
+                })(),
+                subParent,
+                (() => {
+                    const entity = new TestModel();
+                    entity.name = 'Peter';
+                    entity.parent = secondParent;
+                    return entity;
+                })(),
+                (() => {
+                    const entity = new TestModel();
+                    entity.name = 'Warren';
+                    entity.parent = subParent;
+                    return entity;
+                })(),
+                (() => {
+                    const entity = new TestModel();
+                    entity.name = 'Arthur';
+                    entity.parent = subParent;
+                    return entity;
+                })(),
+                firstParent,
+                secondParent,
+            ];
+        };
+        const entities = [];
+        for (let i = 0; i < 100; i++) {
+            entities.push(...getEntries());
+        }
+        const sorter = new Sorter(entities);
+        sorter.hsort('name', 'parent');
+        expect(sorter.array.map((entity) => {
+            let output = '';
+            let parent = entity.parent;
+            while (parent) {
+                output += '- ';
+                parent = parent.parent;
+            }
+            return output + entity.name;
+        })).toEqual([
+            ...[...Array(100)]
+                .map(() => [
+                'Anthony',
+                '- Lamar',
+                '- - Arthur',
+                '- - Warren',
+                '- Peter',
+            ])
+                .flat(),
+            ...[...Array(100)].map(() => ['Herbert', '- Jacob', '- Joshua']).flat(),
+        ]);
+    });
+    it('sorts entities hierarchically with an identical resolver', () => {
+        const firstParent = new TestModel();
+        firstParent.name = 'Herbert';
+        firstParent.fallback = 1;
+        const secondParent = new TestModel();
+        secondParent.name = 'Anthony';
+        secondParent.fallback = 2;
+        const subParent = new TestModel();
+        subParent.name = 'Lamar';
+        subParent.fallback = 3;
+        subParent.parent = secondParent;
+        const entities = [
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Peter';
+                entity.fallback = 5;
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Peter';
+                entity.fallback = 4;
+                entity.parent = firstParent;
+                return entity;
+            })(),
+            subParent,
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Peter';
+                entity.fallback = 7;
+                entity.parent = secondParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Peter';
+                entity.fallback = 8;
+                entity.parent = subParent;
+                return entity;
+            })(),
+            (() => {
+                const entity = new TestModel();
+                entity.name = 'Peter';
+                entity.fallback = 6;
+                entity.parent = subParent;
+                return entity;
+            })(),
+            firstParent,
+            secondParent,
+        ];
+        const sorter = new Sorter(entities);
+        sorter.hsort('name', 'parent', {
+            identiticalResolver: (a, b) => (a.fallback || 0) - (b.fallback || 0),
+        });
+        expect(sorter.array.map((entity) => {
+            let output = '';
+            let parent = entity.parent;
+            while (parent) {
+                output += '- ';
+                parent = parent.parent;
+            }
+            return output + entity.fallback;
+        })).toEqual(['2', '- 3', '- - 6', '- - 8', '- 7', '1', '- 4', '- 5']);
+    });
+    it('sorts array in place', () => {
+        const entities = [];
+        for (const prop of ['d', 'a', 'c', 'e', 'b']) {
+            const entity = new TestModel();
+            entity.name = prop;
+            entities.push(entity);
+        }
+        const sorter = new Sorter(entities);
+        const sorted = sorter.sort('name');
+        expect(entities.map((entity) => entity.name)).toEqual([
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+        ]);
+        expect(sorter.array.map((entity) => entity.name)).toEqual([
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+        ]);
+        expect(sorted.map((entity) => entity.name)).toEqual([
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+        ]);
+    });
+});
+//# sourceMappingURL=Sorter.test.js.map