@daiso-tech/core 0.1.0 → 0.1.2

package/dist/esm/collection/iterable-collection/iterable-collection.js

@@ -0,0 +1,745 @@
+import { CollectionError, ItemNotFoundError, MultipleItemsFoundError, IndexOverflowError, UnexpectedCollectionError, } from "../../contracts/collection/_module";
+import { CrossJoinIterable, SlidingIteralbe, ShuffleIterable, EntriesIterable, FilterIterable, ChunkIterable, ChunkWhileIterable, CollapseIterable, CountByIterable, FlatMapIterable, GroupByIterable, InsertAfterIterable, InsertBeforeIterable, MapIterable, MergeIterable, PadEndIterable, PadStartIterable, PartionIterable, SkipIterable, SkipUntilIterable, SortIterable, SplitIterable, TakeIterable, TakeUntilIterable, TapIterable, UniqueIterable, UpdateIterable, WhenIterable, ZipIterable, ReverseIterable, SliceIterable, RepeatIterable, } from "../../collection/iterable-collection/iterable-helpers/_module";
+export class IterableCollection {
+    iterable;
+    static THROW_ON_NUMBER_LIMIT = false;
+    static DEFAULT_CHUNK_SIZE = 1024;
+    static makeCollection = (iterable = []) => {
+        return new IterableCollection(iterable);
+    };
+    constructor(iterable) {
+        this.iterable = iterable;
+    }
+    *[Symbol.iterator]() {
+        try {
+            yield* this.iterable;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    iterator() {
+        return this[Symbol.iterator]();
+    }
+    entries(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new EntriesIterable(this, throwOnNumberLimit));
+    }
+    keys(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.entries(throwOnNumberLimit).map(([key]) => key);
+    }
+    values() {
+        return this.entries().map(([_key, value]) => value);
+    }
+    filter(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new FilterIterable(this, filter, throwOnNumberLimit));
+    }
+    map(map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new MapIterable(this, map, throwOnNumberLimit));
+    }
+    reduce(settings) {
+        try {
+            const { reduceFn: reduce, initialValue, throwOnNumberLimit, } = settings;
+            if (initialValue === undefined && this.empty()) {
+                throw new TypeError("Reduce of empty array must be inputed a initial value");
+            }
+            if (initialValue !== undefined) {
+                let output = initialValue, index = 0;
+                for (const item of this) {
+                    if (throwOnNumberLimit &&
+                        index === Number.MAX_SAFE_INTEGER) {
+                        throw new IndexOverflowError("Index has overflowed");
+                    }
+                    output = reduce(output, item, index, this);
+                    index++;
+                }
+                return output;
+            }
+            let output = this.firstOrFail(), index = 0, isFirstIteration = true;
+            for (const item of this) {
+                if (!isFirstIteration) {
+                    if (throwOnNumberLimit &&
+                        index === Number.MAX_SAFE_INTEGER) {
+                        throw new IndexOverflowError("Index has overflowed");
+                    }
+                    output = reduce(output, item, index, this);
+                }
+                isFirstIteration = false;
+                index++;
+            }
+            return output;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    join(settings) {
+        try {
+            return this.reduce({
+                reduceFn(str, item) {
+                    if (typeof item !== "string") {
+                        throw new TypeError("Item type is invalid must be string");
+                    }
+                    const separator = settings?.seperator ?? ",";
+                    return str + separator + item;
+                },
+                throwOnNumberLimit: settings?.throwOnNumberLimit ??
+                    IterableCollection.THROW_ON_NUMBER_LIMIT,
+            });
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    collapse() {
+        return new IterableCollection(new CollapseIterable(this));
+    }
+    flatMap(map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new FlatMapIterable(this, map, throwOnNumberLimit));
+    }
+    update(filter, map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new UpdateIterable(this, filter, map, throwOnNumberLimit));
+    }
+    page(settings) {
+        const { page, pageSize, throwOnNumberLimit } = settings;
+        if (page < 0) {
+            return this.skip(page * pageSize, throwOnNumberLimit).take(pageSize, throwOnNumberLimit);
+        }
+        return this.skip((page - 1) * pageSize, throwOnNumberLimit).take(page * pageSize, throwOnNumberLimit);
+    }
+    sum() {
+        try {
+            let sum = 0;
+            for (const item of this) {
+                if (typeof item !== "number") {
+                    throw new TypeError("Item type is invalid must be number");
+                }
+                sum += item;
+            }
+            return sum;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    average() {
+        try {
+            let size = 0, sum = 0;
+            for (const item of this) {
+                if (typeof item !== "number") {
+                    throw new TypeError("Item type is invalid must be number");
+                }
+                size++;
+                sum += item;
+            }
+            return (sum / size);
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    median(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        if (this.empty()) {
+            return 0;
+        }
+        const size = this.size(throwOnNumberLimit);
+        if (size === 0) {
+            return 0;
+        }
+        const isEven = size % 2 === 0, items = this.map((item) => {
+            if (typeof item !== "number") {
+                throw new TypeError("Item type is invalid must be number");
+            }
+            return item;
+        }, throwOnNumberLimit)
+            .filter((_item, index) => {
+            if (isEven) {
+                return index === size / 2 || index === size / 2 - 1;
+            }
+            return index === Math.floor(size / 2);
+        }, throwOnNumberLimit)
+            .toArray();
+        if (isEven) {
+            const [a, b] = items;
+            if (a === undefined) {
+                throw new UnexpectedCollectionError("Is in invalid state");
+            }
+            if (b === undefined) {
+                throw new UnexpectedCollectionError("Is in invalid state");
+            }
+            return ((a + b) / 2);
+        }
+        const [median] = items;
+        if (median === undefined) {
+            throw new UnexpectedCollectionError("Is in invalid state");
+        }
+        return median;
+    }
+    min() {
+        try {
+            let min = 0;
+            for (const item of this) {
+                if (typeof item !== "number") {
+                    throw new TypeError("Item type is invalid must be number");
+                }
+                if (min === 0) {
+                    min = item;
+                }
+                else if (min > item) {
+                    min = item;
+                }
+            }
+            return min;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    max() {
+        try {
+            let max = 0;
+            for (const item of this) {
+                if (typeof item !== "number") {
+                    throw new TypeError("Item type is invalid must be number");
+                }
+                if (max === 0) {
+                    max = item;
+                }
+                else if (max < item) {
+                    max = item;
+                }
+            }
+            return max;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    percentage(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            if (this.empty()) {
+                return 0;
+            }
+            let part = 0, total = 0;
+            for (const item of this) {
+                if (throwOnNumberLimit && total === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("The total amount has overflowed");
+                }
+                if (filter(item, total, this)) {
+                    part++;
+                }
+                total++;
+            }
+            return (part / total) * 100;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    some(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let index = 0;
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (filter(item, index, this)) {
+                    return true;
+                }
+                index++;
+            }
+            return false;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    every(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let index = 0, isTrue = true;
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                isTrue &&= filter(item, index, this);
+                if (!isTrue) {
+                    break;
+                }
+                index++;
+            }
+            return isTrue;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    take(limit, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new TakeIterable(this, limit, throwOnNumberLimit));
+    }
+    takeUntil(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new TakeUntilIterable(this, filter, throwOnNumberLimit));
+    }
+    takeWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.takeUntil((...arguments_) => !filter(...arguments_), throwOnNumberLimit);
+    }
+    skip(offset, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new SkipIterable(this, offset, throwOnNumberLimit));
+    }
+    skipUntil(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new SkipUntilIterable(this, filter, throwOnNumberLimit));
+    }
+    skipWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.skipUntil((...arguments_) => !filter(...arguments_), throwOnNumberLimit);
+    }
+    when(condition, callback) {
+        return new IterableCollection(new WhenIterable(this, () => condition, callback));
+    }
+    whenEmpty(callback) {
+        return new IterableCollection(new WhenIterable(this, () => this.empty(), callback));
+    }
+    whenNot(condition, callback) {
+        return this.when(!condition, callback);
+    }
+    whenNotEmpty(callback) {
+        return new IterableCollection(new WhenIterable(this, () => this.notEmpty(), callback));
+    }
+    pipe(callback) {
+        try {
+            return callback(this);
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    tap(callback) {
+        return new IterableCollection(new TapIterable(this, callback));
+    }
+    chunk(chunkSize) {
+        return new IterableCollection(new ChunkIterable(this, chunkSize, IterableCollection.makeCollection));
+    }
+    chunkWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new ChunkWhileIterable(this, filter, throwOnNumberLimit, (iterable) => new IterableCollection(iterable)));
+    }
+    split(chunkAmount, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new SplitIterable(this, chunkAmount, throwOnNumberLimit, IterableCollection.makeCollection));
+    }
+    partition(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new PartionIterable(this, filter, throwOnNumberLimit, IterableCollection.makeCollection));
+    }
+    sliding(settings) {
+        const { chunkSize, step = chunkSize - 1, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
+        return new IterableCollection(new SlidingIteralbe(this, chunkSize, step, throwOnNumberLimit));
+    }
+    groupBy(settings) {
+        return new IterableCollection(new GroupByIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+            IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
+    }
+    countBy(settings) {
+        return new IterableCollection(new CountByIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+            IterableCollection.THROW_ON_NUMBER_LIMIT));
+    }
+    unique(settings) {
+        return new IterableCollection(new UniqueIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+            IterableCollection.THROW_ON_NUMBER_LIMIT));
+    }
+    difference(iterable, map = (item) => item) {
+        const differenceCollection = new IterableCollection(iterable);
+        return this.filter((item, index, collection) => {
+            return !differenceCollection.some((matchItem, matchIndex, matchCollection) => {
+                return (map(item, index, collection) ===
+                    map(matchItem, matchIndex, matchCollection));
+            });
+        });
+    }
+    repeat(amount) {
+        return new IterableCollection(new RepeatIterable(this, amount, IterableCollection.makeCollection));
+    }
+    padStart(maxLength, fillItems) {
+        return new IterableCollection(new PadStartIterable(this, maxLength, fillItems, IterableCollection.makeCollection));
+    }
+    padEnd(maxLength, fillItems) {
+        return new IterableCollection(new PadEndIterable(this, maxLength, fillItems, IterableCollection.makeCollection));
+    }
+    slice(settings) {
+        return new IterableCollection(new SliceIterable(this, settings?.start, settings?.end, settings?.throwOnNumberLimit ??
+            IterableCollection.THROW_ON_NUMBER_LIMIT));
+    }
+    prepend(iterable) {
+        return new IterableCollection(new MergeIterable(iterable, this));
+    }
+    append(iterable) {
+        return new IterableCollection(new MergeIterable(this, iterable));
+    }
+    insertBefore(filter, iterable, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new InsertBeforeIterable(this, filter, iterable, throwOnNumberLimit));
+    }
+    insertAfter(filter, iterable, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new InsertAfterIterable(this, filter, iterable, throwOnNumberLimit));
+    }
+    crossJoin(...iterables) {
+        return new IterableCollection(new CrossJoinIterable(this, iterables, IterableCollection.makeCollection));
+    }
+    zip(iterable) {
+        return new IterableCollection(new ZipIterable(this, iterable));
+    }
+    sort(compare) {
+        return new IterableCollection(new SortIterable(this, compare));
+    }
+    reverse(settings) {
+        return new IterableCollection(new ReverseIterable(this, settings?.chunkSize ?? IterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnNumberLimit ??
+            IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
+    }
+    shuffle() {
+        return new IterableCollection(new ShuffleIterable(this));
+    }
+    first(settings) {
+        try {
+            return this.firstOr({
+                ...settings,
+                defaultValue: null,
+            });
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    firstOr(settings) {
+        try {
+            const throwOnNumberLimit = settings.throwOnNumberLimit ??
+                IterableCollection.THROW_ON_NUMBER_LIMIT;
+            let index = 0;
+            const filter = settings.filterFn ?? (() => true);
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (filter(item, index, this)) {
+                    return item;
+                }
+                index++;
+            }
+            if (typeof settings.defaultValue === "function") {
+                const defaultFn = settings.defaultValue;
+                return defaultFn();
+            }
+            return settings.defaultValue;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    firstOrFail(settings) {
+        const item = this.first(settings);
+        if (item === null) {
+            throw new ItemNotFoundError("Item was not found");
+        }
+        return item;
+    }
+    last(settings) {
+        try {
+            return this.lastOr({
+                ...settings,
+                defaultValue: null,
+            });
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    lastOr(settings) {
+        try {
+            const throwOnNumberLimit = settings.throwOnNumberLimit ??
+                IterableCollection.THROW_ON_NUMBER_LIMIT;
+            let index = 0;
+            const filter = settings.filterFn ?? (() => true);
+            let matchedItem = null;
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (filter(item, index, this)) {
+                    matchedItem = item;
+                }
+                index++;
+            }
+            if (matchedItem) {
+                return matchedItem;
+            }
+            if (typeof settings.defaultValue === "function") {
+                const defaultFn = settings.defaultValue;
+                return defaultFn();
+            }
+            return settings.defaultValue;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    lastOrFail(settings) {
+        const item = this.last(settings);
+        if (item === null) {
+            throw new ItemNotFoundError("Item was not found");
+        }
+        return item;
+    }
+    before(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.beforeOr(null, filter, throwOnNumberLimit);
+    }
+    beforeOr(defaultValue, filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let beforeItem = null, index = 0;
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (filter(item, index, this) && beforeItem) {
+                    return beforeItem;
+                }
+                index++;
+                beforeItem = item;
+            }
+            if (typeof defaultValue === "function") {
+                const defaultFn = defaultValue;
+                return defaultFn();
+            }
+            return defaultValue;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    beforeOrFail(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        const item = this.before(filter, throwOnNumberLimit);
+        if (item === null) {
+            throw new ItemNotFoundError("Item was not found");
+        }
+        return item;
+    }
+    after(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.afterOr(null, filter, throwOnNumberLimit);
+    }
+    afterOr(defaultValue, filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let hasMatched = false, index = 0;
+            for (const item of this) {
+                if (hasMatched) {
+                    return item;
+                }
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                hasMatched = filter(item, index, this);
+                index++;
+            }
+            if (typeof defaultValue === "function") {
+                const defaultFn = defaultValue;
+                return defaultFn();
+            }
+            return defaultValue;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    afterOrFail(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        const item = this.after(filter, throwOnNumberLimit);
+        if (item === null) {
+            throw new ItemNotFoundError("Item was not found");
+        }
+        return item;
+    }
+    sole(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let index = 0, matchedItem = null;
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (filter(item, index, this)) {
+                    if (matchedItem !== null) {
+                        throw new MultipleItemsFoundError("Multiple items were found");
+                    }
+                    matchedItem = item;
+                }
+                index++;
+            }
+            if (matchedItem === null) {
+                throw new ItemNotFoundError("Item was not found");
+            }
+            return matchedItem;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    nth(step) {
+        return this.filter((_item, index) => index % step === 0);
+    }
+    count(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let size = 0;
+            for (const item of this) {
+                if (throwOnNumberLimit && size === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Size has overflowed");
+                }
+                if (filter(item, size, this)) {
+                    size++;
+                }
+            }
+            return size;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    size(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.count(() => true, throwOnNumberLimit);
+    }
+    empty() {
+        try {
+            for (const _ of this) {
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    notEmpty() {
+        return !this.empty();
+    }
+    search(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let index = 0;
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (filter(item, index, this)) {
+                    return index;
+                }
+                index++;
+            }
+            return -1;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    forEach(callback, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let index = 0;
+            for (const item of this) {
+                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                callback(item, index, this);
+                index++;
+            }
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    toArray() {
+        try {
+            return [...this];
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+}
+//# sourceMappingURL=iterable-collection.js.map