@blueprint-ts/core 4.1.0-beta.6 → 5.0.0

package/dist/bulkRequests/BulkRequestSender.js

@@ -1,12 +1,3 @@
-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) {
@@ -14,12 +5,15 @@ export var BulkRequestExecutionMode;
     BulkRequestExecutionMode["SEQUENTIAL"] = "sequential";
 })(BulkRequestExecutionMode || (BulkRequestExecutionMode = {}));
 export class BulkRequestSender {
+    requests;
+    executionMode;
+    retryCount;
+    events = new Map();
+    abortController = undefined;
     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;
@@ -52,110 +46,95 @@ export class BulkRequestSender {
         callbacks.forEach((callback) => callback(req));
     }
     get signal() {
-        var _a;
-        return (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal;
+        return this.abortController?.signal;
     }
     abort() {
-        var _a;
-        (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+        this.abortController?.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();
-                }
+    async send() {
+        this.abortController = new AbortController();
+        try {
+            if (this.executionMode === BulkRequestExecutionMode.PARALLEL) {
+                await this.sendParallel();
             }
-            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);
+            else {
+                await this.sendSequential();
             }
-            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())
-            };
-        });
+        }
+        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--;
+    async sendParallel() {
+        // First attempt for all requests
+        await Promise.all(this.requests.map((req) => req.send(this.abortController?.signal).then(() => {
+            if (!req.hasError()) {
+                this.emit(BulkRequestEventEnum.REQUEST_SUCCESSFUL, req);
             }
-            // 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);
+        })));
+        // 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}`);
+            await Promise.all(failedRequests.map((req) => req.send(this.abortController?.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);
+        });
+    }
+    async sendSequential() {
+        // First attempt for all requests
+        for (const req of this.requests) {
+            await req.send(this.abortController?.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);
-                    }
+        }
+        // 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) {
+                await req.send(this.abortController?.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);
-            });
+            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.js

@@ -1,33 +1,23 @@
-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 {
+    request;
+    response = null;
+    error = null;
+    sent = false;
     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;
+    }
+    async send(signal) {
+        try {
+            if (signal !== undefined) {
+                this.request.setAbortSignal(signal);
             }
-            this.sent = true;
-        });
+            this.response = await this.request.send();
+        }
+        catch (err) {
+            console.error(err);
+            this.error = err;
+        }
+        this.sent = true;
     }
     isLoading() {
         return this.request.isLoading();

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

@@ -1,5 +1,6 @@
 import { PaginationDataDto } from '../../../pagination/dtos/PaginationDataDto';
 export class RequestDriver {
+    request;
     constructor(request) {
         this.request = request;
     }

package/dist/pagination/BasePaginator.js

@@ -1,8 +1,9 @@
 import { PaginationDataDto } from './dtos/PaginationDataDto';
 export class BasePaginator {
+    dataDriver;
+    initialized = false;
     constructor(dataDriver) {
         this.dataDriver = dataDriver;
-        this.initialized = false;
     }
     isInitialized() {
         return this.initialized;
@@ -36,13 +37,12 @@ export class BasePaginator {
         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) {
+            if (options?.adjustTotal ?? true) {
                 this.viewDriver.setTotal(Math.max(0, this.viewDriver.getTotal() - removed));
             }
         }
@@ -52,7 +52,7 @@ export class BasePaginator {
         return this.viewDriver.getTotal();
     }
     passDataToViewDriver(dto, options) {
-        if (options === null || options === void 0 ? void 0 : options.flush) {
+        if (options?.flush) {
             this.flush();
         }
         this.viewDriver.setData(dto.getData());

package/dist/pagination/PageAwarePaginator.js

@@ -1,13 +1,16 @@
 import { BasePaginator } from './BasePaginator';
 import { StaleResponseException } from '../requests/exceptions/StaleResponseException';
 export class PageAwarePaginator extends BasePaginator {
+    dataDriver;
+    static viewDriverFactory;
+    viewDriver;
     static setViewDriverFactory(value) {
         PageAwarePaginator.viewDriverFactory = value;
     }
     constructor(dataDriver, pageNumber = 1, pageSize = 10, options) {
         super(dataDriver);
         this.dataDriver = dataDriver;
-        this.viewDriver = (options === null || options === void 0 ? void 0 : options.viewDriverFactory)
+        this.viewDriver = options?.viewDriverFactory
             ? options.viewDriverFactory.make(pageNumber, pageSize)
             : PageAwarePaginator.viewDriverFactory.make(pageNumber, pageSize);
     }

package/dist/pagination/StatePaginator.js

@@ -1,13 +1,16 @@
 import { BasePaginator } from './BasePaginator';
 export class StatePaginator extends BasePaginator {
+    dataDriver;
+    static viewDriverFactory;
+    viewDriver;
+    currentState = null;
     static setViewDriverFactory(value) {
         StatePaginator.viewDriverFactory = value;
     }
     constructor(dataDriver, options) {
         super(dataDriver);
         this.dataDriver = dataDriver;
-        this.currentState = null;
-        this.viewDriver = (options === null || options === void 0 ? void 0 : options.viewDriverFactory)
+        this.viewDriver = options?.viewDriverFactory
             ? options.viewDriverFactory.make()
             : StatePaginator.viewDriverFactory.make();
     }
@@ -20,7 +23,7 @@ export class StatePaginator extends BasePaginator {
     }
     load(options) {
         this.currentState = null;
-        return this.loadData(Object.assign(Object.assign({}, options), { flush: true }));
+        return this.loadData({ ...options, flush: true });
     }
     loadNext() {
         return this.loadData();

package/dist/pagination/dataDrivers/ArrayDriver.js

@@ -1,5 +1,6 @@
 import { PaginationDataDto } from '../index';
 export class ArrayDriver {
+    data;
     constructor(data) {
         this.data = data;
     }

package/dist/pagination/dtos/PaginationDataDto.js

@@ -1,4 +1,6 @@
 export class PaginationDataDto {
+    data;
+    total;
     constructor(data, total) {
         this.data = data;
         this.total = total;

package/dist/pagination/dtos/StatePaginationDataDto.js

@@ -1,5 +1,6 @@
 import { PaginationDataDto } from './PaginationDataDto';
 export class StatePaginationDataDto extends PaginationDataDto {
+    state;
     constructor(data, total, state = null) {
         super(data, total);
         this.state = state;

package/dist/pagination/frontendDrivers/VueBaseViewDriver.js

@@ -1,5 +1,7 @@
 import { ref } from 'vue';
 export class VueBaseViewDriver {
+    dataRef;
+    totalRef;
     constructor() {
         this.dataRef = ref([]);
         this.totalRef = ref(0);

package/dist/pagination/frontendDrivers/VuePaginationDriver.js

@@ -1,5 +1,11 @@
 import { computed, ref } from 'vue';
 export class VuePaginationDriver {
+    dataRef;
+    currentPageRef;
+    pageSizeRef;
+    totalRef;
+    totalPagesComputed;
+    pagesComputed;
     constructor(pageNumber, pageSize) {
         this.dataRef = ref([]);
         this.currentPageRef = ref(pageNumber);

package/dist/persistenceDrivers/LocalStorageDriver.js

@@ -1,4 +1,5 @@
 export class LocalStorageDriver {
+    suffix;
     constructor(suffix) {
         this.suffix = suffix;
     }

package/dist/persistenceDrivers/MemoryPersistenceDriver.js

@@ -1,4 +1,6 @@
 export class MemoryPersistenceDriver {
+    suffix;
+    static store = new Map();
     constructor(suffix) {
         this.suffix = suffix;
     }
@@ -19,4 +21,3 @@ export class MemoryPersistenceDriver {
         MemoryPersistenceDriver.store.delete(this.storageKey(key));
     }
 }
-MemoryPersistenceDriver.store = new Map();

package/dist/persistenceDrivers/SessionStorageDriver.js

@@ -1,4 +1,5 @@
 export class SessionStorageDriver {
+    suffix;
     constructor(suffix) {
         this.suffix = suffix;
     }