@stnekroman/tstools
Version:
Set of handy tools for TypeScript development
188 lines (187 loc) • 7.44 kB
JavaScript
"use strict";
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GroupBy = GroupBy;
const Arrays_1 = require("./Arrays");
const Functions_1 = require("./Functions");
const Objects_1 = require("./Objects");
function GroupBy(data) {
return {
toObject(field) {
return new GroupBy.ObjectGroupByBuilder(Functions_1.Functions.extractor(field)).build().consumeAll(data).result;
},
toMap(field) {
return (new GroupBy.MapGroupByBuilder(Functions_1.Functions.extractor(field)).build().consumeAll(data).result);
}
};
}
(function (GroupBy) {
var _ObjectGroupByAccumulator_result, _MapGroupByAccumulator_result, _ArrayAccumulator_result;
class Accumulator {
consumeAll(datas) {
for (const data of datas) {
this.consume(data);
}
return this;
}
}
GroupBy.Accumulator = Accumulator;
function toObject() {
return {
byExtractor(extractor) {
return new ObjectGroupByBuilder(extractor);
},
byField(field) {
return new ObjectGroupByBuilder(Functions_1.Functions.extractor(field));
}
};
}
GroupBy.toObject = toObject;
function toMap() {
return {
byExtractor(extractor) {
return new MapGroupByBuilder(extractor);
},
byField(field) {
return new MapGroupByBuilder(Functions_1.Functions.extractor(field));
}
};
}
GroupBy.toMap = toMap;
class ObjectGroupByBuilder {
constructor(keyExtractor) {
this.keyExtractor = keyExtractor;
}
valueExtractor(extractor) {
return new ObjectGroupByBuilderWithValue(this.keyExtractor, extractor);
}
build(groupAccumulatorsFactory) {
return new ObjectGroupByBuilderWithValue(this.keyExtractor, i => i).build(groupAccumulatorsFactory);
}
}
GroupBy.ObjectGroupByBuilder = ObjectGroupByBuilder;
class MapGroupByBuilder {
constructor(keyExtractor) {
this.keyExtractor = keyExtractor;
}
valueExtractor(extractor) {
return new MapGroupByBuilderWithValue(this.keyExtractor, extractor);
}
build(groupAccumulatorsFactory) {
return new MapGroupByBuilderWithValue(this.keyExtractor, i => i).build(groupAccumulatorsFactory);
}
}
GroupBy.MapGroupByBuilder = MapGroupByBuilder;
class ObjectGroupByBuilderWithValue {
constructor(keyExtractor, valueExtractor) {
this.keyExtractor = keyExtractor;
this.valueExtractor = valueExtractor;
}
build(groupAccumulatorsFactory) {
if (!groupAccumulatorsFactory) {
groupAccumulatorsFactory = () => new ArrayAccumulator();
}
return new ObjectGroupByAccumulator(this.keyExtractor, this.valueExtractor, groupAccumulatorsFactory);
}
}
class MapGroupByBuilderWithValue {
constructor(keyExtractor, valueExtractor) {
this.keyExtractor = keyExtractor;
this.valueExtractor = valueExtractor;
}
build(groupAccumulatorsFactory) {
if (!groupAccumulatorsFactory) {
groupAccumulatorsFactory = () => new ArrayAccumulator();
}
return new MapGroupByAccumulator(this.keyExtractor, this.valueExtractor, groupAccumulatorsFactory);
}
}
class GroupByAccumulator extends Accumulator {
constructor(keyExtractor, valueExtractor, groupAccumulatorsFactory) {
super();
this.keyExtractor = keyExtractor;
this.valueExtractor = valueExtractor;
this.groupAccumulatorsFactory = groupAccumulatorsFactory;
this.groupAccumulators = new Map();
}
consume(data) {
const key = this.keyExtractor(data);
const value = this.valueExtractor(data);
let groupAccumulator = this.groupAccumulators.get(key);
if (groupAccumulator === undefined) {
groupAccumulator = this.groupAccumulatorsFactory();
this.groupAccumulators.set(key, groupAccumulator);
this.set(key, groupAccumulator.result);
}
groupAccumulator.consume(value);
return this;
}
clear() {
this.groupAccumulators.clear();
}
}
class ObjectGroupByAccumulator extends GroupByAccumulator {
constructor() {
super(...arguments);
_ObjectGroupByAccumulator_result.set(this, Object.create(null));
}
set(key, group) {
__classPrivateFieldGet(this, _ObjectGroupByAccumulator_result, "f")[key] = group;
}
get result() {
return __classPrivateFieldGet(this, _ObjectGroupByAccumulator_result, "f");
}
clear() {
super.clear();
Objects_1.Objects.forEach(__classPrivateFieldGet(this, _ObjectGroupByAccumulator_result, "f"), (key) => {
delete __classPrivateFieldGet(this, _ObjectGroupByAccumulator_result, "f")[key];
});
}
}
_ObjectGroupByAccumulator_result = new WeakMap();
GroupBy.ObjectGroupByAccumulator = ObjectGroupByAccumulator;
class MapGroupByAccumulator extends GroupByAccumulator {
constructor() {
super(...arguments);
_MapGroupByAccumulator_result.set(this, new Map());
}
set(key, group) {
__classPrivateFieldGet(this, _MapGroupByAccumulator_result, "f").set(key, group);
}
get result() {
return __classPrivateFieldGet(this, _MapGroupByAccumulator_result, "f");
}
clear() {
super.clear();
__classPrivateFieldGet(this, _MapGroupByAccumulator_result, "f").clear();
}
}
_MapGroupByAccumulator_result = new WeakMap();
GroupBy.MapGroupByAccumulator = MapGroupByAccumulator;
class ArrayAccumulator extends Accumulator {
constructor() {
super(...arguments);
_ArrayAccumulator_result.set(this, []);
}
consume(data) {
__classPrivateFieldGet(this, _ArrayAccumulator_result, "f").push(data);
return this;
}
consumeAll(datas) {
Arrays_1.Arrays.pushAll(__classPrivateFieldGet(this, _ArrayAccumulator_result, "f"), datas);
return this;
}
get result() {
return __classPrivateFieldGet(this, _ArrayAccumulator_result, "f");
}
clear() {
__classPrivateFieldGet(this, _ArrayAccumulator_result, "f").length = 0;
}
}
_ArrayAccumulator_result = new WeakMap();
GroupBy.ArrayAccumulator = ArrayAccumulator;
})(GroupBy || (exports.GroupBy = GroupBy = {}));