@blueprint-ts/core 4.1.0-beta.2 → 4.1.0-beta.4

package/dist/bulkRequests/BulkRequestEvent.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum BulkRequestEventEnum {
+    REQUEST_SUCCESSFUL = "REQUEST_SUCCESSFUL",
+    REQUEST_FAILED = "REQUEST_FAILED"
+}

package/dist/bulkRequests/BulkRequestEvent.enum.js

@@ -0,0 +1,5 @@
+export var BulkRequestEventEnum;
+(function (BulkRequestEventEnum) {
+    BulkRequestEventEnum["REQUEST_SUCCESSFUL"] = "REQUEST_SUCCESSFUL";
+    BulkRequestEventEnum["REQUEST_FAILED"] = "REQUEST_FAILED";
+})(BulkRequestEventEnum || (BulkRequestEventEnum = {}));

package/dist/bulkRequests/BulkRequestSender.d.ts

@@ -0,0 +1,31 @@
+import { BulkRequestWrapper } from './BulkRequestWrapper';
+import { BulkRequestEventEnum } from './BulkRequestEvent.enum';
+export declare enum BulkRequestExecutionMode {
+    PARALLEL = "parallel",
+    SEQUENTIAL = "sequential"
+}
+export declare class BulkRequestSender<RequestLoaderLoadingType = unknown, RequestBodyInterface = unknown, ResponseClass = unknown, RequestParamsInterface extends object = object> {
+    protected requests: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>[];
+    protected executionMode: BulkRequestExecutionMode;
+    protected retryCount: number;
+    protected events: Map<BulkRequestEventEnum, ((req: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>) => void)[]>;
+    protected abortController: AbortController | undefined;
+    constructor(requests?: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>[], executionMode?: BulkRequestExecutionMode, retryCount?: number);
+    setRequests(requests?: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>[]): this;
+    setExecutionMode(mode: BulkRequestExecutionMode): this;
+    setRetryCount(count: number): this;
+    get isLoading(): boolean;
+    on(event: BulkRequestEventEnum, callback: (req: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>) => void): this;
+    off(event: BulkRequestEventEnum): this;
+    protected emit(event: BulkRequestEventEnum, req: BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>): void;
+    get signal(): AbortSignal | undefined;
+    abort(): void;
+    send(): Promise<{
+        getSuccessCount: () => number;
+        getErrorCount: () => number;
+        getSuccessfulResponses: () => ResponseClass[];
+        getFailedResponses: () => unknown[];
+    }>;
+    protected sendParallel(): Promise<void>;
+    protected sendSequential(): Promise<void>;
+}

package/dist/bulkRequests/BulkRequestSender.js

@@ -0,0 +1,161 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BulkRequestEventEnum } from './BulkRequestEvent.enum';
+export var BulkRequestExecutionMode;
+(function (BulkRequestExecutionMode) {
+    BulkRequestExecutionMode["PARALLEL"] = "parallel";
+    BulkRequestExecutionMode["SEQUENTIAL"] = "sequential";
+})(BulkRequestExecutionMode || (BulkRequestExecutionMode = {}));
+export class BulkRequestSender {
+    constructor(requests = [], executionMode = BulkRequestExecutionMode.PARALLEL, retryCount = 0) {
+        this.requests = requests;
+        this.executionMode = executionMode;
+        this.retryCount = retryCount;
+        this.events = new Map();
+        this.abortController = undefined;
+    }
+    setRequests(requests = []) {
+        this.requests = requests;
+        return this;
+    }
+    setExecutionMode(mode) {
+        this.executionMode = mode;
+        return this;
+    }
+    setRetryCount(count) {
+        this.retryCount = count;
+        return this;
+    }
+    get isLoading() {
+        return this.requests.some((req) => Boolean(req.isLoading()));
+    }
+    on(event, callback) {
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+        this.events.get(event).push(callback);
+        return this;
+    }
+    off(event) {
+        this.events.delete(event);
+        return this;
+    }
+    emit(event, req) {
+        const callbacks = this.events.get(event) || [];
+        callbacks.forEach((callback) => callback(req));
+    }
+    get signal() {
+        var _a;
+        return (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal;
+    }
+    abort() {
+        var _a;
+        (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+    }
+    send() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.abortController = new AbortController();
+            try {
+                if (this.executionMode === BulkRequestExecutionMode.PARALLEL) {
+                    yield this.sendParallel();
+                }
+                else {
+                    yield this.sendSequential();
+                }
+            }
+            catch (error) {
+                // If an abort occurs, the underlying fetch (or request mechanism) should throw an AbortError.
+                console.error('Bulk operation aborted or encountered an error:', error);
+            }
+            return {
+                getSuccessCount: () => this.requests.filter((r) => !r.hasError()).length,
+                getErrorCount: () => this.requests.filter((r) => r.hasError()).length,
+                getSuccessfulResponses: () => this.requests
+                    .filter((r) => !r.hasError())
+                    .map((r) => r.getResponse())
+                    .filter((response) => response !== null),
+                getFailedResponses: () => this.requests.filter((r) => r.hasError()).map((r) => r.getError())
+            };
+        });
+    }
+    sendParallel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // First attempt for all requests
+            yield Promise.all(this.requests.map((req) => {
+                var _a;
+                return req.send((_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal).then(() => {
+                    if (!req.hasError()) {
+                        this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req);
+                    }
+                });
+            }));
+            // Retry logic for failed requests
+            let retriesLeft = this.retryCount;
+            while (retriesLeft > 0) {
+                const failedRequests = this.requests.filter((req) => req.hasError());
+                if (failedRequests.length === 0) {
+                    break; // No failed requests to retry
+                }
+                console.log(`Retrying ${failedRequests.length} failed requests. Attempts left: ${retriesLeft}`);
+                yield Promise.all(failedRequests.map((req) => {
+                    var _a;
+                    return req.send((_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal).then(() => {
+                        if (!req.hasError()) {
+                            // Success after retry
+                            this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req);
+                        }
+                    });
+                }));
+                retriesLeft--;
+            }
+            // Emit failed events for any requests that still have errors after all retries
+            this.requests
+                .filter((req) => req.hasError())
+                .forEach((req) => {
+                this.emit(BulkRequestEventEnum.REQUEST_FAILED, req);
+            });
+        });
+    }
+    sendSequential() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // First attempt for all requests
+            for (const req of this.requests) {
+                yield req.send((_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal);
+                if (!req.hasError()) {
+                    this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req);
+                }
+            }
+            // Retry logic for failed requests
+            let retriesLeft = this.retryCount;
+            while (retriesLeft > 0) {
+                const failedRequests = this.requests.filter((req) => req.hasError());
+                if (failedRequests.length === 0) {
+                    break; // No failed requests to retry
+                }
+                console.log(`Retrying ${failedRequests.length} failed requests sequentially. Attempts left: ${retriesLeft}`);
+                for (const req of failedRequests) {
+                    yield req.send((_b = this.abortController) === null || _b === void 0 ? void 0 : _b.signal);
+                    if (!req.hasError()) {
+                        // Success after retry
+                        this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req);
+                    }
+                }
+                retriesLeft--;
+            }
+            // Emit failed events for any requests that still have errors after all retries
+            this.requests
+                .filter((req) => req.hasError())
+                .forEach((req) => {
+                this.emit(BulkRequestEventEnum.REQUEST_FAILED, req);
+            });
+        });
+    }
+}

package/dist/bulkRequests/BulkRequestWrapper.d.ts

@@ -0,0 +1,15 @@
+import { type BaseRequestContract } from '../requests';
+export declare class BulkRequestWrapper<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface extends object> {
+    protected request: BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>;
+    protected response: ResponseClass | null;
+    protected error: unknown | null;
+    protected sent: boolean;
+    constructor(request: BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>);
+    send(signal?: AbortSignal): Promise<void>;
+    isLoading(): RequestLoaderLoadingType;
+    getResponse(): ResponseClass | null;
+    getError(): unknown | null;
+    getRequest(): BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface>;
+    hasError(): boolean;
+    wasSent(): boolean;
+}

package/dist/bulkRequests/BulkRequestWrapper.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class BulkRequestWrapper {
+    constructor(request) {
+        this.request = request;
+        this.response = null;
+        this.error = null;
+        this.sent = false;
+    }
+    send(signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (signal !== undefined) {
+                    this.request.setAbortSignal(signal);
+                }
+                this.response = yield this.request.send();
+            }
+            catch (err) {
+                console.error(err);
+                this.error = err;
+            }
+            this.sent = true;
+        });
+    }
+    isLoading() {
+        return this.request.isLoading();
+    }
+    getResponse() {
+        return this.response;
+    }
+    getError() {
+        return this.error;
+    }
+    getRequest() {
+        return this.request;
+    }
+    hasError() {
+        return this.error !== null;
+    }
+    wasSent() {
+        return this.sent;
+    }
+}

package/dist/bulkRequests/index.d.ts

@@ -0,0 +1,5 @@
+import { BulkRequestWrapper } from './BulkRequestWrapper';
+import { BulkRequestSender } from './BulkRequestSender';
+import { BulkRequestEventEnum } from './BulkRequestEvent.enum';
+import { BulkRequestExecutionMode } from './BulkRequestSender';
+export { BulkRequestEventEnum, BulkRequestWrapper, BulkRequestSender, BulkRequestExecutionMode };

package/dist/bulkRequests/index.js

@@ -0,0 +1,5 @@
+import { BulkRequestWrapper } from './BulkRequestWrapper';
+import { BulkRequestSender } from './BulkRequestSender';
+import { BulkRequestEventEnum } from './BulkRequestEvent.enum';
+import { BulkRequestExecutionMode } from './BulkRequestSender';
+export { BulkRequestEventEnum, BulkRequestWrapper, BulkRequestSender, BulkRequestExecutionMode };

package/{src/laravel/pagination/contracts/PaginationResponseBodyContract.ts → dist/laravel/pagination/contracts/PaginationResponseBodyContract.d.ts}

@@ -1,6 +1,6 @@
 export interface PaginationResponseBodyContract<ResourceInterface> {
-  data: ResourceInterface
-  meta: {
-    total: number
-  }
+    data: ResourceInterface;
+    meta: {
+        total: number;
+    };
 }

package/dist/laravel/pagination/contracts/PaginationResponseBodyContract.js

@@ -0,0 +1 @@
+export {};

package/dist/laravel/pagination/dataDrivers/RequestDriver.d.ts

@@ -0,0 +1,10 @@
+import { PaginationDataDto } from '../../../pagination/dtos/PaginationDataDto';
+import { PaginationResponse } from '../../requests/responses/PaginationResponse';
+import { type PaginateableRequestContract } from '../../../pagination/contracts/PaginateableRequestContract';
+import { type PaginationDataDriverContract } from '../../../pagination/contracts/PaginationDataDriverContract';
+export declare class RequestDriver<Resource, TReq extends PaginateableRequestContract<unknown, PaginationResponse<Resource>, unknown, object> = PaginateableRequestContract<unknown, PaginationResponse<Resource>, unknown, object>> implements PaginationDataDriverContract<Resource> {
+    protected request: TReq;
+    constructor(request: TReq);
+    get(pageNumber: number, pageSize: number): Promise<PaginationDataDto<Resource>>;
+    getRequest(): TReq;
+}

package/dist/laravel/pagination/dataDrivers/RequestDriver.js

@@ -0,0 +1,18 @@
+import { PaginationDataDto } from '../../../pagination/dtos/PaginationDataDto';
+export class RequestDriver {
+    constructor(request) {
+        this.request = request;
+    }
+    get(pageNumber, pageSize) {
+        return this.request
+            .setPaginationParams(pageNumber, pageSize)
+            .send()
+            .then((response) => {
+            const paginationResponse = response;
+            return new PaginationDataDto(paginationResponse.getData(), paginationResponse.getTotal());
+        });
+    }
+    getRequest() {
+        return this.request;
+    }
+}

package/dist/laravel/pagination/index.d.ts

@@ -0,0 +1,4 @@
+import { type PaginationResponseBodyContract } from './contracts/PaginationResponseBodyContract';
+import { RequestDriver } from './dataDrivers/RequestDriver';
+export type { PaginationResponseBodyContract };
+export { RequestDriver };

package/dist/laravel/pagination/index.js

@@ -0,0 +1,2 @@
+import { RequestDriver } from './dataDrivers/RequestDriver';
+export { RequestDriver };

package/dist/laravel/requests/JsonBaseRequest.d.ts

@@ -0,0 +1,14 @@
+import { BaseRequest } from '../../requests/BaseRequest';
+import { JsonResponse } from './responses/JsonResponse';
+import { type BodyFactoryContract } from '../../requests/contracts/BodyFactoryContract';
+export interface JsonResponseInterface<ResourceInterface> {
+    data: ResourceInterface;
+}
+/**
+ * This requests expects a response in the JSON format
+ * and automatically sets the required headers.
+ */
+export declare abstract class JsonBaseRequest<RequestLoaderLoadingType, ResponseErrorBody, ResourceInterface, RequestBodyInterface = undefined, RequestParamsInterface extends object = object> extends BaseRequest<RequestLoaderLoadingType, ResponseErrorBody, JsonResponseInterface<ResourceInterface>, JsonResponse<ResourceInterface>, RequestBodyInterface, RequestParamsInterface> {
+    getResponse(): JsonResponse<ResourceInterface>;
+    getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface | undefined>;
+}

package/dist/laravel/requests/JsonBaseRequest.js

@@ -0,0 +1,15 @@
+import { BaseRequest } from '../../requests/BaseRequest';
+import { JsonResponse } from './responses/JsonResponse';
+import { JsonBodyFactory } from '../../requests/factories/JsonBodyFactory';
+/**
+ * This requests expects a response in the JSON format
+ * and automatically sets the required headers.
+ */
+export class JsonBaseRequest extends BaseRequest {
+    getResponse() {
+        return new JsonResponse();
+    }
+    getRequestBodyFactory() {
+        return new JsonBodyFactory();
+    }
+}

package/dist/laravel/requests/PaginationJsonBaseRequest.d.ts

@@ -0,0 +1,8 @@
+import { BaseRequest } from '../../requests/BaseRequest';
+import { type PaginationResponseBodyContract } from '../pagination/contracts/PaginationResponseBodyContract';
+import { type PaginationResponseContract } from '../../pagination/contracts/PaginationResponseContract';
+import { PaginationResponse } from './responses/PaginationResponse';
+export declare abstract class PaginationJsonBaseRequest<RequestLoaderLoadingType, ResponseErrorBodyInterface, ResourceInterface, RequestParamsInterface extends object> extends BaseRequest<RequestLoaderLoadingType, ResponseErrorBodyInterface, PaginationResponseBodyContract<ResourceInterface>, PaginationResponseContract<PaginationResponseBodyContract<ResourceInterface>, ResourceInterface>, undefined, RequestParamsInterface> {
+    getResponse(): PaginationResponse<ResourceInterface>;
+    setPaginationParams(page: number, size: number): this;
+}

package/dist/laravel/requests/PaginationJsonBaseRequest.js

@@ -0,0 +1,13 @@
+import { BaseRequest } from '../../requests/BaseRequest';
+import { PaginationResponse } from './responses/PaginationResponse';
+export class PaginationJsonBaseRequest extends BaseRequest {
+    getResponse() {
+        return new PaginationResponse();
+    }
+    setPaginationParams(page, size) {
+        return this.withParams({
+            page_number: page,
+            page_size: size
+        });
+    }
+}

package/dist/laravel/requests/index.d.ts

@@ -0,0 +1,7 @@
+import { JsonResponse } from './responses/JsonResponse';
+import { PaginationResponse } from './responses/PaginationResponse';
+import { JsonBaseRequest } from './JsonBaseRequest';
+import { PaginationJsonBaseRequest } from './PaginationJsonBaseRequest';
+import { type JsonResponseInterface } from './JsonBaseRequest';
+export { JsonResponse, PaginationResponse, JsonBaseRequest, PaginationJsonBaseRequest };
+export type { JsonResponseInterface };

package/dist/laravel/requests/index.js

@@ -0,0 +1,5 @@
+import { JsonResponse } from './responses/JsonResponse';
+import { PaginationResponse } from './responses/PaginationResponse';
+import { JsonBaseRequest } from './JsonBaseRequest';
+import { PaginationJsonBaseRequest } from './PaginationJsonBaseRequest';
+export { JsonResponse, PaginationResponse, JsonBaseRequest, PaginationJsonBaseRequest };

package/dist/laravel/requests/responses/JsonResponse.d.ts

@@ -0,0 +1,5 @@
+import { JsonResponse as ParentJsonResponse } from '../../../requests/responses/JsonResponse';
+import { type JsonResponseInterface } from '../JsonBaseRequest';
+export declare class JsonResponse<ResourceInterface> extends ParentJsonResponse<JsonResponseInterface<ResourceInterface>> {
+    getData(): ResourceInterface;
+}

package/dist/laravel/requests/responses/JsonResponse.js

@@ -0,0 +1,6 @@
+import { JsonResponse as ParentJsonResponse } from '../../../requests/responses/JsonResponse';
+export class JsonResponse extends ParentJsonResponse {
+    getData() {
+        return this.getBody().data;
+    }
+}

package/dist/laravel/requests/responses/PaginationResponse.d.ts

@@ -0,0 +1,7 @@
+import { JsonResponse } from '../../../requests/responses/JsonResponse';
+import { type PaginationResponseBodyContract } from '../../pagination/contracts/PaginationResponseBodyContract';
+import { type PaginationResponseContract } from '../../../pagination/contracts/PaginationResponseContract';
+export declare class PaginationResponse<ResourceInterface> extends JsonResponse<PaginationResponseBodyContract<ResourceInterface>> implements PaginationResponseContract<PaginationResponseBodyContract<ResourceInterface>, ResourceInterface> {
+    getTotal(): number;
+    getData(): ResourceInterface;
+}

package/dist/laravel/requests/responses/PaginationResponse.js

@@ -0,0 +1,9 @@
+import { JsonResponse } from '../../../requests/responses/JsonResponse';
+export class PaginationResponse extends JsonResponse {
+    getTotal() {
+        return this.getBody().meta.total;
+    }
+    getData() {
+        return this.getBody().data;
+    }
+}

package/dist/pagination/BasePaginator.d.ts

@@ -0,0 +1,19 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto';
+import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract';
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions';
+export declare abstract class BasePaginator<ResourceInterface, ViewDriver extends BaseViewDriverContract<ResourceInterface[]>> {
+    protected dataDriver: unknown;
+    protected initialized: boolean;
+    protected abstract viewDriver: ViewDriver;
+    constructor(dataDriver: unknown);
+    isInitialized(): boolean;
+    flush(): void;
+    getPageData(): ResourceInterface[];
+    updateRows(predicate: (row: ResourceInterface, index: number, data: ResourceInterface[]) => boolean, updater: (row: ResourceInterface, index: number, data: ResourceInterface[]) => ResourceInterface | void): number;
+    removeRows(predicate: (row: ResourceInterface, index: number, data: ResourceInterface[]) => boolean, options?: {
+        adjustTotal?: boolean;
+    }): number;
+    getTotal(): number;
+    protected passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void;
+    protected handleStaleResponse(): PaginationDataDto<ResourceInterface[]>;
+}

package/dist/pagination/BasePaginator.js

@@ -0,0 +1,65 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto';
+export class BasePaginator {
+    constructor(dataDriver) {
+        this.dataDriver = dataDriver;
+        this.initialized = false;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    flush() {
+        this.viewDriver.setData([]);
+    }
+    getPageData() {
+        return this.viewDriver.getData();
+    }
+    updateRows(predicate, updater) {
+        const data = this.viewDriver.getData();
+        let updated = 0;
+        for (let i = 0; i < data.length; i++) {
+            const row = data[i];
+            if (row === undefined) {
+                continue;
+            }
+            if (!predicate(row, i, data)) {
+                continue;
+            }
+            const result = updater(row, i, data);
+            if (result !== undefined) {
+                data[i] = result;
+            }
+            updated++;
+        }
+        if (updated > 0) {
+            this.viewDriver.setData(data);
+        }
+        return updated;
+    }
+    removeRows(predicate, options) {
+        var _a;
+        const data = this.viewDriver.getData();
+        const next = data.filter((row, index) => !predicate(row, index, data));
+        const removed = data.length - next.length;
+        if (removed > 0) {
+            this.viewDriver.setData(next);
+            if ((_a = options === null || options === void 0 ? void 0 : options.adjustTotal) !== null && _a !== void 0 ? _a : true) {
+                this.viewDriver.setTotal(Math.max(0, this.viewDriver.getTotal() - removed));
+            }
+        }
+        return removed;
+    }
+    getTotal() {
+        return this.viewDriver.getTotal();
+    }
+    passDataToViewDriver(dto, options) {
+        if (options === null || options === void 0 ? void 0 : options.flush) {
+            this.flush();
+        }
+        this.viewDriver.setData(dto.getData());
+        this.viewDriver.setTotal(dto.getTotal());
+        this.initialized = true;
+    }
+    handleStaleResponse() {
+        return new PaginationDataDto(this.viewDriver.getData(), this.viewDriver.getTotal());
+    }
+}

package/dist/pagination/InfiniteScroller.d.ts

@@ -0,0 +1,6 @@
+import { PageAwarePaginator } from './PageAwarePaginator';
+import { PaginationDataDto } from './dtos/PaginationDataDto';
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions';
+export declare class InfiniteScroller<ResourceInterface> extends PageAwarePaginator<ResourceInterface> {
+    protected passDataToViewDriver(dto: PaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void;
+}

package/dist/pagination/InfiniteScroller.js

@@ -0,0 +1,17 @@
+import { PageAwarePaginator } from './PageAwarePaginator';
+export class InfiniteScroller extends PageAwarePaginator {
+    passDataToViewDriver(dto, options = {}) {
+        const { flush = false, replace = false } = options;
+        if (flush) {
+            this.flush();
+        }
+        if (replace) {
+            this.viewDriver.setData(dto.getData());
+        }
+        else {
+            this.viewDriver.setData(this.viewDriver.getData().concat(dto.getData()));
+        }
+        this.viewDriver.setTotal(dto.getTotal());
+        this.initialized = true;
+    }
+}

package/dist/pagination/PageAwarePaginator.d.ts

@@ -0,0 +1,32 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto';
+import { type ViewDriverContract } from './contracts/ViewDriverContract';
+import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryContract';
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions';
+import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract';
+import { BasePaginator } from './BasePaginator';
+export interface PageAwarePaginatorOptions {
+    viewDriverFactory?: ViewDriverFactoryContract;
+}
+export declare class PageAwarePaginator<ResourceInterface> extends BasePaginator<ResourceInterface, ViewDriverContract<ResourceInterface[]>> {
+    protected dataDriver: PaginationDataDriverContract<ResourceInterface[]>;
+    protected static viewDriverFactory: ViewDriverFactoryContract;
+    protected viewDriver: ViewDriverContract<ResourceInterface[]>;
+    static setViewDriverFactory(value: ViewDriverFactoryContract): void;
+    constructor(dataDriver: PaginationDataDriverContract<ResourceInterface[]>, pageNumber?: number, pageSize?: number, options?: PageAwarePaginatorOptions);
+    setDataDriver(dataDriver: PaginationDataDriverContract<ResourceInterface[]>): this;
+    getDataDriver(): PaginationDataDriverContract<ResourceInterface[]>;
+    load(pageNumber?: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>>;
+    setPageNumber(pageNumber: number): this;
+    getLastPage(): number;
+    toNextPage(): Promise<PaginationDataDto<ResourceInterface[]>>;
+    toFirstPage(): Promise<PaginationDataDto<ResourceInterface[]>>;
+    toLastPage(): Promise<PaginationDataDto<ResourceInterface[]>>;
+    toPreviousPage(): Promise<PaginationDataDto<ResourceInterface[]>>;
+    getCurrentPage(): number;
+    getFromItemNumber(): number;
+    getToItemNumber(): number;
+    getPageSize(): number;
+    setPageSize(pageSize: number): this;
+    getPages(): number[];
+    protected loadData(pageNumber: number, pageSize: number, options?: PaginatorLoadDataOptions): Promise<PaginationDataDto<ResourceInterface[]>>;
+}