@daiso-tech/core 0.0.1 → 0.1.1

package/dist/types/collection/iterable-collection/iterable-helpers/unique-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection, type Map } from "../../../contracts/collection/_module";
+export declare class UniqueIterable<TInput, TOutput> implements Iterable<TInput> {
+    private collection;
+    private callback;
+    private throwOnNumberLimit;
+    constructor(collection: ICollection<TInput>, callback: Map<TInput, ICollection<TInput>, TOutput>, throwOnNumberLimit: boolean);
+    [Symbol.iterator](): Iterator<TInput>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/update-iterable.d.ts

@@ -0,0 +1,9 @@
+import { type Filter, type ICollection, type Map, type UpdatedItem } from "../../../contracts/collection/_module";
+export declare class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<UpdatedItem<TInput, TFilterOutput, TMapOutput>> {
+    private collection;
+    private filter;
+    private map;
+    private throwOnNumberLimit;
+    constructor(collection: ICollection<TInput>, filter: Filter<TInput, ICollection<TInput>, TFilterOutput>, map: Map<TFilterOutput, ICollection<TInput>, TMapOutput>, throwOnNumberLimit: boolean);
+    [Symbol.iterator](): Iterator<UpdatedItem<TInput, TFilterOutput, TMapOutput>>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/when-iterable.d.ts

@@ -0,0 +1,8 @@
+import { type ICollection, type Modifier } from "../../../contracts/collection/_module";
+export declare class WhenIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
+    private collection;
+    private condition;
+    private callback;
+    constructor(collection: ICollection<TInput>, condition: () => boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>);
+    [Symbol.iterator](): Iterator<TInput | TExtended>;
+}

package/dist/types/collection/iterable-collection/iterable-helpers/zip-iterable.d.ts

@@ -0,0 +1,7 @@
+import { type RecordItem } from "../../../contracts/collection/_module";
+export declare class ZipIterable<TInput, TExtended> implements Iterable<RecordItem<TInput, TExtended>> {
+    private iterableA;
+    private iterableB;
+    constructor(iterableA: Iterable<TInput>, iterableB: Iterable<TExtended>);
+    [Symbol.iterator](): Iterator<RecordItem<TInput, TExtended>>;
+}

package/dist/types/collection/list-collection/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../collection/list-collection/list-collection";

package/dist/types/collection/list-collection/list-collection.d.ts

@@ -0,0 +1,86 @@
+import { type Collapse, type Comparator, type Filter, type FindOrSettings, type FindSettings, type ForEach, type GroupBySettings, type ICollection, type JoinSettings, type Lazyable, type Map, type Modifier, type PageSettings, type RecordItem, type ReduceSettings, type ReverseSettings, type SliceSettings, type SlidingSettings, type Tap, type Transform, type UpdatedItem } from "../../contracts/collection/_module";
+import { EnsureType } from "../../types";
+/**
+ * All methods in ListCollection are eager and therefore will run immediately.
+ * @group Collections
+ */
+export declare class ListCollection<TInput> implements ICollection<TInput> {
+    private array;
+    constructor(iterable: Iterable<TInput>);
+    [Symbol.iterator](): Iterator<TInput>;
+    iterator(): Iterator<TInput, void>;
+    entries(_throwOnNumberLimit?: boolean): ICollection<RecordItem<number, TInput>>;
+    keys(_throwOnNumberLimit?: boolean): ICollection<number>;
+    values(): ICollection<TInput>;
+    filter<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, _throwOnNumberLimit?: boolean): ICollection<TOutput>;
+    map<TOutput>(map: Map<TInput, ICollection<TInput>, TOutput>, _throwOnNumberLimit?: boolean): ICollection<TOutput>;
+    reduce<TOutput = TInput>(settings: ReduceSettings<TInput, ICollection<TInput>, TOutput>): TOutput;
+    join(settings?: JoinSettings): string;
+    collapse(): ICollection<Collapse<TInput>>;
+    flatMap<TOutput>(map: Map<TInput, ICollection<TInput>, Iterable<TOutput>>, _throwOnNumberLimit?: boolean): ICollection<TOutput>;
+    update<TFilterOutput extends TInput, TMapOutput>(filter: Filter<TInput, ICollection<TInput>, TFilterOutput>, map: Map<TFilterOutput, ICollection<TInput>, TMapOutput>, _throwOnNumberLimit?: boolean): ICollection<UpdatedItem<TInput, TFilterOutput, TMapOutput>>;
+    page(settings: PageSettings): ICollection<TInput>;
+    sum(_throwOnNumberLimit?: boolean): EnsureType<TInput, number>;
+    average(_throwOnNumberLimit?: boolean): EnsureType<TInput, number>;
+    median(_throwOnNumberLimit?: boolean): EnsureType<TInput, number>;
+    min(): EnsureType<TInput, number>;
+    max(): EnsureType<TInput, number>;
+    percentage(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): number;
+    some<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, _throwOnNumberLimit?: boolean): boolean;
+    every<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, _throwOnNumberLimit?: boolean): boolean;
+    take(limit: number, _throwOnNumberLimit?: boolean): ICollection<TInput>;
+    takeUntil(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): ICollection<TInput>;
+    takeWhile(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): ICollection<TInput>;
+    skip(offset: number, _throwOnNumberLimit?: boolean): ICollection<TInput>;
+    skipUntil(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): ICollection<TInput>;
+    skipWhile(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): ICollection<TInput>;
+    when<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNot<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNotEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    pipe<TOutput = TInput>(callback: Transform<ICollection<TInput>, TOutput>): TOutput;
+    tap(callback: Tap<ICollection<TInput>>): ICollection<TInput>;
+    chunk(chunkSize: number): ICollection<ICollection<TInput>>;
+    chunkWhile(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): ICollection<ICollection<TInput>>;
+    split(chunkAmount: number, _throwOnNumberLimit?: boolean): ICollection<ICollection<TInput>>;
+    partition(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): ICollection<ICollection<TInput>>;
+    sliding(settings: SlidingSettings): ICollection<ICollection<TInput>>;
+    groupBy<TOutput = TInput>(settings?: GroupBySettings<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, ICollection<TInput>>>;
+    countBy<TOutput = TInput>(settings?: GroupBySettings<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, number>>;
+    unique<TOutput = TInput>(settings?: GroupBySettings<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    difference<TOutput = TInput>(iterable: Iterable<TInput>, map?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    repeat(amount: number): ICollection<TInput>;
+    padStart<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    padEnd<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    slice(settings?: SliceSettings): ICollection<TInput>;
+    prepend<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    append<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    insertBefore<TExtended = TInput>(filter: Filter<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>, _throwOnNumberLimit?: boolean): ICollection<TInput | TExtended>;
+    insertAfter<TExtended = TInput>(filter: Filter<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>, _throwOnNumberLimit?: boolean): ICollection<TInput | TExtended>;
+    crossJoin<TExtended = TInput>(...iterables: Array<Iterable<TExtended>>): ICollection<ICollection<TInput | TExtended>>;
+    zip<TExtended>(iterable: Iterable<TExtended>): ICollection<RecordItem<TInput, TExtended>>;
+    sort(compare?: Comparator<TInput>): ICollection<TInput>;
+    reverse(_settings?: ReverseSettings): ICollection<TInput>;
+    shuffle(): ICollection<TInput>;
+    first<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    firstOr<TOutput extends TInput, TExtended = TInput>(settings: FindOrSettings<TInput, ICollection<TInput>, TOutput, TExtended>): TOutput | TExtended;
+    firstOrFail<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput;
+    last<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    lastOr<TOutput extends TInput, TExtended = TInput>(settings: FindOrSettings<TInput, ICollection<TInput>, TOutput, TExtended>): TOutput | TExtended;
+    lastOrFail<TOutput extends TInput>(settings?: FindSettings<TInput, ICollection<TInput>, TOutput>): TOutput;
+    before(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): TInput | null;
+    beforeOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): TInput | TExtended;
+    beforeOrFail(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): TInput;
+    after(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): TInput | null;
+    afterOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): TInput | TExtended;
+    afterOrFail(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): TInput;
+    sole<TOutput extends TInput>(filter: Filter<TInput, ICollection<TInput>, TOutput>, _throwOnNumberLimit?: boolean): TOutput;
+    nth(step: number): ICollection<TInput>;
+    count(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): number;
+    size(_throwOnNumberLimit?: boolean): number;
+    empty(): boolean;
+    notEmpty(): boolean;
+    search(filter: Filter<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): number;
+    forEach(callback: ForEach<TInput, ICollection<TInput>>, _throwOnNumberLimit?: boolean): void;
+    toArray(): TInput[];
+}

package/dist/types/contracts/_module.d.ts

@@ -0,0 +1 @@
+export * from "../collection/_module";

package/dist/types/contracts/collection/_module.d.ts

@@ -0,0 +1,3 @@
+export * from "../../contracts/collection/_shared";
+export * from "../../contracts/collection/collection.contract";
+export * from "../../contracts/collection/async-collection.contract";

package/dist/types/contracts/collection/_shared.d.ts

@@ -0,0 +1,259 @@
+/**
+ * @group Collections
+ */
+export declare class CollectionError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Collections
+ */
+export declare class UnexpectedCollectionError extends CollectionError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Collections
+ */
+export declare class IndexOverflowError extends UnexpectedCollectionError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Collections
+ */
+export declare class ItemNotFoundError extends CollectionError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Collections
+ */
+export declare class MultipleItemsFoundError extends CollectionError {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Collections
+ */
+export type UpdatedItem<TInput, TFilterOutput, TMapOutput> = TInput | TFilterOutput | TMapOutput;
+/**
+ * @group Collections
+ */
+export type RecordItem<TKey, TValue> = [key: TKey, value: TValue];
+/**
+ * @group Collections
+ */
+export type ReverseSettings = {
+    chunkSize?: number;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type PageSettings = {
+    page: number;
+    pageSize: number;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type JoinSettings = {
+    seperator?: string;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type SliceSettings = {
+    start?: number;
+    end?: number;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type SlidingSettings = {
+    chunkSize: number;
+    step?: number;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type Comparator<TItem> = (itemA: TItem, itemB: TItem) => number;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type Filter_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => boolean;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type FilterGuard<TInput, TCollection, TOutput extends TInput = TInput> = (item: TInput, index: number, collection: TCollection) => item is TOutput;
+/**
+ * @group Collections
+ */
+export type Filter<TInput, TCollection, TOutput extends TInput = TInput> = Filter_<TInput, TCollection> | FilterGuard<TInput, TCollection, TOutput>;
+/**
+ * @group Collections
+ */
+export type Reduce<TInput, TCollection, TOutput> = (output: TOutput, item: TInput, index: number, collection: TCollection) => TOutput;
+/**
+ * @group Collections
+ */
+export type ReduceSettings<TInput, TCollection, TOutput> = {
+    reduceFn: Reduce<TInput, TCollection, TOutput>;
+    initialValue?: TOutput;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type Map<TInput, TCollection, TOutput> = (item: TInput, index: number, collection: TCollection) => TOutput;
+/**
+ * @group Collections
+ */
+export type ForEach<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => void;
+/**
+ * @group Collections
+ */
+export type Modifier<TInput, TOutput> = (collection: TInput) => TOutput;
+/**
+ * @group Collections
+ */
+export type Tap<TCollection> = (collection: TCollection) => void;
+/**
+ * @group Collections
+ */
+export type Transform<TInput, TOutput> = (value: TInput) => TOutput;
+/**
+ * @group Collections
+ */
+export type Lazyable<TValue> = TValue | (() => TValue);
+/**
+ * @group Collections
+ */
+export type FindSettings<TInput, TCollection, TOutput extends TInput> = {
+    filterFn?: Filter<TInput, TCollection, TOutput>;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type FindOrSettings<TInput, TCollection, TOutput extends TInput, TDefault> = FindSettings<TInput, TCollection, TOutput> & {
+    defaultValue: Lazyable<TDefault>;
+};
+/**
+ * @group Collections
+ */
+export type GroupBySettings<TInput, TCollection, TOutput> = {
+    mapFn?: Map<TInput, TCollection, TOutput>;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncFilter_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => Promise<boolean>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncFilter<TInput, TCollection, TOutput extends TInput = TInput> = AsyncFilter_<TInput, TCollection> | Filter<TInput, TCollection, TOutput>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncReduce_<TInput, TCollection, TOutput> = (output: TOutput, item: TInput, index: number, collection: TCollection) => Promise<TOutput>;
+/**
+ * @group Collections
+ */
+export type AsyncReduce<TInput, TCollection, TOutput> = AsyncReduce_<TInput, TCollection, TOutput> | Reduce<TInput, TCollection, TOutput>;
+/**
+ * @group Collections
+ */
+export type AsyncReduceSettings<TInput, TCollection, TOutput> = {
+    reduceFn: AsyncReduce<TInput, TCollection, TOutput>;
+    initialValue?: TOutput;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncMap_<TInput, TCollection, TOutput> = (item: TInput, index: number, collection: TCollection) => Promise<TOutput>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncMap<TInput, TCollection, TOutput> = AsyncMap_<TInput, TCollection, TOutput> | Map<TInput, TCollection, TOutput>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncForEach_<TInput, TCollection> = (item: TInput, index: number, collection: TCollection) => Promise<void>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncForEach<TInput, TCollection> = ForEach<TInput, TCollection> | AsyncForEach_<TInput, TCollection>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncModifier_<TInput, TOutput> = (collection: TInput) => Promise<TOutput>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncModifier<TInput, TOutput> = Modifier<TInput, TOutput> | AsyncModifier_<TInput, TOutput>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncTap_<TCollection> = (collection: TCollection) => Promise<void>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncTap<TCollection> = Tap<TCollection> | AsyncTap_<TCollection>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncTransform_<TInput, TOutput> = (value: TInput) => Promise<TOutput>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncTransform<TInput, TOutput> = Transform<TInput, TOutput> | AsyncTransform_<TInput, TOutput>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncLazyable_<TValue> = TValue | (() => Promise<TValue>);
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncLazyable<TValue> = AsyncLazyable_<TValue> | Lazyable<TValue>;
+/**
+ * @group Collections
+ *  @internal
+ */
+export type AsyncFindSettings<TInput, TCollection, TOutput extends TInput> = {
+    filterFn?: AsyncFilter<TInput, TCollection, TOutput>;
+    throwOnNumberLimit?: boolean;
+};
+/**
+ * @group Collections
+ */
+export type AsyncFindOrSettings<TInput, TCollection, TOutput extends TInput, TDefault> = AsyncFindSettings<TInput, TCollection, TOutput> & {
+    defaultValue: AsyncLazyable<TDefault>;
+};
+/**
+ * @group Collections
+ */
+export type AsyncGroupBySettings<TInput, TCollection, TOutput> = {
+    mapFn?: AsyncMap<TInput, TCollection, TOutput>;
+    chunkSize?: number;
+    throwOnNumberLimit?: boolean;
+};