@gravity-ui/data-source 0.6.1 → 0.7.0

package/build/esm/core/utils/__tests__/getStatus.test.js

@@ -0,0 +1,47 @@
+import { getStatus } from '../getStatus';
+describe('getStatus', function () {
+  it('should return success when all statuses are success', function () {
+    var states = [{
+      status: 'success'
+    }, {
+      status: 'success'
+    }, {
+      status: 'success'
+    }];
+    expect(getStatus(states)).toBe('success');
+  });
+  it('should return loading when at least one status is loading', function () {
+    var states = [{
+      status: 'success'
+    }, {
+      status: 'loading'
+    }, {
+      status: 'success'
+    }];
+    expect(getStatus(states)).toBe('loading');
+  });
+  it('should return error when at least one status is error', function () {
+    var states = [{
+      status: 'success'
+    }, {
+      status: 'error'
+    }, {
+      status: 'success'
+    }];
+    expect(getStatus(states)).toBe('error');
+  });
+  it('should prioritize error over loading', function () {
+    var states = [{
+      status: 'loading'
+    }, {
+      status: 'error'
+    }, {
+      status: 'success'
+    }];
+    expect(getStatus(states)).toBe('error');
+  });
+  it('should handle empty array', function () {
+    expect(getStatus([])).toBe('success');
+  });
+});
+// #sourceMappingURL=getStatus.test.js.map

package/build/esm/core/utils/__tests__/getStatus.test.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getStatus","describe","it","states","status","expect","toBe"],"sources":["getStatus.test.ts"],"sourcesContent":["import type {DataLoaderStatus} from '../../types/DataLoaderStatus';\nimport {getStatus} from '../getStatus';\n\ndescribe('getStatus', () => {\n    it('should return success when all statuses are success', () => {\n        const states = [\n            {status: 'success' as DataLoaderStatus},\n            {status: 'success' as DataLoaderStatus},\n            {status: 'success' as DataLoaderStatus},\n        ];\n        expect(getStatus(states)).toBe('success');\n    });\n\n    it('should return loading when at least one status is loading', () => {\n        const states = [\n            {status: 'success' as DataLoaderStatus},\n            {status: 'loading' as DataLoaderStatus},\n            {status: 'success' as DataLoaderStatus},\n        ];\n        expect(getStatus(states)).toBe('loading');\n    });\n\n    it('should return error when at least one status is error', () => {\n        const states = [\n            {status: 'success' as DataLoaderStatus},\n            {status: 'error' as DataLoaderStatus},\n            {status: 'success' as DataLoaderStatus},\n        ];\n        expect(getStatus(states)).toBe('error');\n    });\n\n    it('should prioritize error over loading', () => {\n        const states = [\n            {status: 'loading' as DataLoaderStatus},\n            {status: 'error' as DataLoaderStatus},\n            {status: 'success' as DataLoaderStatus},\n        ];\n        expect(getStatus(states)).toBe('error');\n    });\n\n    it('should handle empty array', () => {\n        expect(getStatus([])).toBe('success');\n    });\n});\n"],"mappings":"AACA,SAAQA,SAAS,QAAO,cAAc;AAEtCC,QAAQ,CAAC,WAAW,EAAE,YAAM;EACxBC,EAAE,CAAC,qDAAqD,EAAE,YAAM;IAC5D,IAAMC,MAAM,GAAG,CACX;MAACC,MAAM,EAAE;IAA6B,CAAC,EACvC;MAACA,MAAM,EAAE;IAA6B,CAAC,EACvC;MAACA,MAAM,EAAE;IAA6B,CAAC,CAC1C;IACDC,MAAM,CAACL,SAAS,CAACG,MAAM,CAAC,CAAC,CAACG,IAAI,CAAC,SAAS,CAAC;EAC7C,CAAC,CAAC;EAEFJ,EAAE,CAAC,2DAA2D,EAAE,YAAM;IAClE,IAAMC,MAAM,GAAG,CACX;MAACC,MAAM,EAAE;IAA6B,CAAC,EACvC;MAACA,MAAM,EAAE;IAA6B,CAAC,EACvC;MAACA,MAAM,EAAE;IAA6B,CAAC,CAC1C;IACDC,MAAM,CAACL,SAAS,CAACG,MAAM,CAAC,CAAC,CAACG,IAAI,CAAC,SAAS,CAAC;EAC7C,CAAC,CAAC;EAEFJ,EAAE,CAAC,uDAAuD,EAAE,YAAM;IAC9D,IAAMC,MAAM,GAAG,CACX;MAACC,MAAM,EAAE;IAA6B,CAAC,EACvC;MAACA,MAAM,EAAE;IAA2B,CAAC,EACrC;MAACA,MAAM,EAAE;IAA6B,CAAC,CAC1C;IACDC,MAAM,CAACL,SAAS,CAACG,MAAM,CAAC,CAAC,CAACG,IAAI,CAAC,OAAO,CAAC;EAC3C,CAAC,CAAC;EAEFJ,EAAE,CAAC,sCAAsC,EAAE,YAAM;IAC7C,IAAMC,MAAM,GAAG,CACX;MAACC,MAAM,EAAE;IAA6B,CAAC,EACvC;MAACA,MAAM,EAAE;IAA2B,CAAC,EACrC;MAACA,MAAM,EAAE;IAA6B,CAAC,CAC1C;IACDC,MAAM,CAACL,SAAS,CAACG,MAAM,CAAC,CAAC,CAACG,IAAI,CAAC,OAAO,CAAC;EAC3C,CAAC,CAAC;EAEFJ,EAAE,CAAC,2BAA2B,EAAE,YAAM;IAClCG,MAAM,CAACL,SAAS,CAAC,EAAE,CAAC,CAAC,CAACM,IAAI,CAAC,SAAS,CAAC;EACzC,CAAC,CAAC;AACN,CAAC,CAAC","ignoreList":[]}

package/build/esm/core/utils/__tests__/hasTag.test.js

@@ -0,0 +1,29 @@
+import { hasTag } from '../hasTag';
+describe('hasTag', function () {
+  it('should return true when key contains tag', function () {
+    var key = ['dataSource', 'tag1', 'tag2', 'fullKey'];
+    var tag = 'tag1';
+    expect(hasTag(key, tag)).toBe(true);
+  });
+  it('should return false when key does not contain tag', function () {
+    var key = ['dataSource', 'tag1', 'tag2', 'fullKey'];
+    var tag = 'tag3';
+    expect(hasTag(key, tag)).toBe(false);
+  });
+  it('should return false when tag is at first position (data source name)', function () {
+    var key = ['tag1', 'tag2', 'tag3', 'fullKey'];
+    var tag = 'tag1';
+    expect(hasTag(key, tag)).toBe(false);
+  });
+  it('should return false when tag is at last position (full key)', function () {
+    var key = ['dataSource', 'tag1', 'tag2', 'tag3'];
+    var tag = 'tag3';
+    expect(hasTag(key, tag)).toBe(false);
+  });
+  it('should return false when key is not an array', function () {
+    var key = 'not an array';
+    var tag = 'tag';
+    expect(hasTag(key, tag)).toBe(false);
+  });
+});
+// #sourceMappingURL=hasTag.test.js.map

package/build/esm/core/utils/__tests__/hasTag.test.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hasTag","describe","it","key","tag","expect","toBe"],"sources":["hasTag.test.ts"],"sourcesContent":["import type {DataSourceKey, DataSourceTag} from '../../types/DataSource';\nimport {hasTag} from '../hasTag';\n\ndescribe('hasTag', () => {\n    it('should return true when key contains tag', () => {\n        const key: DataSourceKey = ['dataSource', 'tag1', 'tag2', 'fullKey'];\n        const tag: DataSourceTag = 'tag1';\n        expect(hasTag(key, tag)).toBe(true);\n    });\n\n    it('should return false when key does not contain tag', () => {\n        const key: DataSourceKey = ['dataSource', 'tag1', 'tag2', 'fullKey'];\n        const tag: DataSourceTag = 'tag3';\n        expect(hasTag(key, tag)).toBe(false);\n    });\n\n    it('should return false when tag is at first position (data source name)', () => {\n        const key: DataSourceKey = ['tag1', 'tag2', 'tag3', 'fullKey'];\n        const tag: DataSourceTag = 'tag1';\n        expect(hasTag(key, tag)).toBe(false);\n    });\n\n    it('should return false when tag is at last position (full key)', () => {\n        const key: DataSourceKey = ['dataSource', 'tag1', 'tag2', 'tag3'];\n        const tag: DataSourceTag = 'tag3';\n        expect(hasTag(key, tag)).toBe(false);\n    });\n\n    it('should return false when key is not an array', () => {\n        const key = 'not an array';\n        const tag: DataSourceTag = 'tag';\n        expect(hasTag(key as unknown as DataSourceKey, tag)).toBe(false);\n    });\n});\n"],"mappings":"AACA,SAAQA,MAAM,QAAO,WAAW;AAEhCC,QAAQ,CAAC,QAAQ,EAAE,YAAM;EACrBC,EAAE,CAAC,0CAA0C,EAAE,YAAM;IACjD,IAAMC,GAAkB,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC;IACpE,IAAMC,GAAkB,GAAG,MAAM;IACjCC,MAAM,CAACL,MAAM,CAACG,GAAG,EAAEC,GAAG,CAAC,CAAC,CAACE,IAAI,CAAC,IAAI,CAAC;EACvC,CAAC,CAAC;EAEFJ,EAAE,CAAC,mDAAmD,EAAE,YAAM;IAC1D,IAAMC,GAAkB,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC;IACpE,IAAMC,GAAkB,GAAG,MAAM;IACjCC,MAAM,CAACL,MAAM,CAACG,GAAG,EAAEC,GAAG,CAAC,CAAC,CAACE,IAAI,CAAC,KAAK,CAAC;EACxC,CAAC,CAAC;EAEFJ,EAAE,CAAC,sEAAsE,EAAE,YAAM;IAC7E,IAAMC,GAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC;IAC9D,IAAMC,GAAkB,GAAG,MAAM;IACjCC,MAAM,CAACL,MAAM,CAACG,GAAG,EAAEC,GAAG,CAAC,CAAC,CAACE,IAAI,CAAC,KAAK,CAAC;EACxC,CAAC,CAAC;EAEFJ,EAAE,CAAC,6DAA6D,EAAE,YAAM;IACpE,IAAMC,GAAkB,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IACjE,IAAMC,GAAkB,GAAG,MAAM;IACjCC,MAAM,CAACL,MAAM,CAACG,GAAG,EAAEC,GAAG,CAAC,CAAC,CAACE,IAAI,CAAC,KAAK,CAAC;EACxC,CAAC,CAAC;EAEFJ,EAAE,CAAC,8CAA8C,EAAE,YAAM;IACrD,IAAMC,GAAG,GAAG,cAAc;IAC1B,IAAMC,GAAkB,GAAG,KAAK;IAChCC,MAAM,CAACL,MAAM,CAACG,GAAG,EAA8BC,GAAG,CAAC,CAAC,CAACE,IAAI,CAAC,KAAK,CAAC;EACpE,CAAC,CAAC;AACN,CAAC,CAAC","ignoreList":[]}

package/build/esm/core/utils/__tests__/mergeStatuses.test.js

@@ -0,0 +1,23 @@
+import { mergeStatuses } from '../mergeStatuses';
+describe('mergeStatuses', function () {
+  it('should return success when all statuses are success', function () {
+    var statuses = ['success', 'success', 'success'];
+    expect(mergeStatuses(statuses)).toBe('success');
+  });
+  it('should return loading when at least one status is loading', function () {
+    var statuses = ['success', 'loading', 'success'];
+    expect(mergeStatuses(statuses)).toBe('loading');
+  });
+  it('should return error when at least one status is error', function () {
+    var statuses = ['success', 'error', 'success'];
+    expect(mergeStatuses(statuses)).toBe('error');
+  });
+  it('should prioritize error over loading', function () {
+    var statuses = ['loading', 'error', 'success'];
+    expect(mergeStatuses(statuses)).toBe('error');
+  });
+  it('should handle empty array', function () {
+    expect(mergeStatuses([])).toBe('success');
+  });
+});
+// #sourceMappingURL=mergeStatuses.test.js.map

package/build/esm/core/utils/__tests__/mergeStatuses.test.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["mergeStatuses","describe","it","statuses","expect","toBe"],"sources":["mergeStatuses.test.ts"],"sourcesContent":["import type {DataLoaderStatus} from '../../types/DataLoaderStatus';\nimport {mergeStatuses} from '../mergeStatuses';\n\ndescribe('mergeStatuses', () => {\n    it('should return success when all statuses are success', () => {\n        const statuses: DataLoaderStatus[] = ['success', 'success', 'success'];\n        expect(mergeStatuses(statuses)).toBe('success');\n    });\n\n    it('should return loading when at least one status is loading', () => {\n        const statuses: DataLoaderStatus[] = ['success', 'loading', 'success'];\n        expect(mergeStatuses(statuses)).toBe('loading');\n    });\n\n    it('should return error when at least one status is error', () => {\n        const statuses: DataLoaderStatus[] = ['success', 'error', 'success'];\n        expect(mergeStatuses(statuses)).toBe('error');\n    });\n\n    it('should prioritize error over loading', () => {\n        const statuses: DataLoaderStatus[] = ['loading', 'error', 'success'];\n        expect(mergeStatuses(statuses)).toBe('error');\n    });\n\n    it('should handle empty array', () => {\n        expect(mergeStatuses([])).toBe('success');\n    });\n});\n"],"mappings":"AACA,SAAQA,aAAa,QAAO,kBAAkB;AAE9CC,QAAQ,CAAC,eAAe,EAAE,YAAM;EAC5BC,EAAE,CAAC,qDAAqD,EAAE,YAAM;IAC5D,IAAMC,QAA4B,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC;IACtEC,MAAM,CAACJ,aAAa,CAACG,QAAQ,CAAC,CAAC,CAACE,IAAI,CAAC,SAAS,CAAC;EACnD,CAAC,CAAC;EAEFH,EAAE,CAAC,2DAA2D,EAAE,YAAM;IAClE,IAAMC,QAA4B,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC;IACtEC,MAAM,CAACJ,aAAa,CAACG,QAAQ,CAAC,CAAC,CAACE,IAAI,CAAC,SAAS,CAAC;EACnD,CAAC,CAAC;EAEFH,EAAE,CAAC,uDAAuD,EAAE,YAAM;IAC9D,IAAMC,QAA4B,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC;IACpEC,MAAM,CAACJ,aAAa,CAACG,QAAQ,CAAC,CAAC,CAACE,IAAI,CAAC,OAAO,CAAC;EACjD,CAAC,CAAC;EAEFH,EAAE,CAAC,sCAAsC,EAAE,YAAM;IAC7C,IAAMC,QAA4B,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC;IACpEC,MAAM,CAACJ,aAAa,CAACG,QAAQ,CAAC,CAAC,CAACE,IAAI,CAAC,OAAO,CAAC;EACjD,CAAC,CAAC;EAEFH,EAAE,CAAC,2BAA2B,EAAE,YAAM;IAClCE,MAAM,CAACJ,aAAa,CAAC,EAAE,CAAC,CAAC,CAACK,IAAI,CAAC,SAAS,CAAC;EAC7C,CAAC,CAAC;AACN,CAAC,CAAC","ignoreList":[]}

package/build/esm/core/utils/__tests__/skipContext.test.js

@@ -0,0 +1,67 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import { skipContext } from '../skipContext';
+describe('skipContext', function () {
+  it('should ignore context and query function context parameters', function () {
+    var mockFn = jest.fn(function (arg1, arg2) {
+      return "".concat(arg1, "-").concat(arg2);
+    });
+    var wrappedFn = skipContext(mockFn);
+    var result = wrappedFn('context', 'queryFnContext', 'hello', 42);
+    expect(mockFn).toHaveBeenCalledWith('hello', 42);
+    expect(result).toBe('hello-42');
+  });
+  it('should work with functions that have no parameters', function () {
+    var mockFn = jest.fn(function () {
+      return 'result';
+    });
+    var wrappedFn = skipContext(mockFn);
+    var result = wrappedFn('context', 'queryFnContext');
+    expect(mockFn).toHaveBeenCalledWith();
+    expect(result).toBe('result');
+  });
+  it('should work with async functions', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    var mockFn, wrappedFn, result;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          mockFn = jest.fn(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(arg) {
+              return _regeneratorRuntime().wrap(function _callee$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    return _context.abrupt("return", "async-".concat(arg));
+                  case 1:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _callee);
+            }));
+            return function (_x) {
+              return _ref2.apply(this, arguments);
+            };
+          }());
+          wrappedFn = skipContext(mockFn);
+          _context2.next = 4;
+          return wrappedFn('context', 'queryFnContext', 'test');
+        case 4:
+          result = _context2.sent;
+          expect(mockFn).toHaveBeenCalledWith('test');
+          expect(result).toBe('async-test');
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('should pass multiple arguments correctly', function () {
+    var mockFn = jest.fn(function (arg1, arg2, arg3) {
+      return "".concat(arg1, "-").concat(arg2, "-").concat(arg3);
+    });
+    var wrappedFn = skipContext(mockFn);
+    var result = wrappedFn('context', 'queryFnContext', 'hello', 42, true);
+    expect(mockFn).toHaveBeenCalledWith('hello', 42, true);
+    expect(result).toBe('hello-42-true');
+  });
+});
+// #sourceMappingURL=skipContext.test.js.map

package/build/esm/core/utils/__tests__/skipContext.test.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["skipContext","describe","it","mockFn","jest","fn","arg1","arg2","concat","wrappedFn","result","expect","toHaveBeenCalledWith","toBe","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","wrap","_callee2$","_context2","prev","next","_ref2","_callee","arg","_callee$","_context","abrupt","stop","_x","apply","arguments","sent","arg3"],"sources":["skipContext.test.ts"],"sourcesContent":["import {skipContext} from '../skipContext';\n\ndescribe('skipContext', () => {\n    it('should ignore context and query function context parameters', () => {\n        const mockFn = jest.fn((arg1: string, arg2: number) => `${arg1}-${arg2}`);\n        const wrappedFn = skipContext(mockFn);\n        const result = wrappedFn('context', 'queryFnContext', 'hello', 42);\n        expect(mockFn).toHaveBeenCalledWith('hello', 42);\n        expect(result).toBe('hello-42');\n    });\n\n    it('should work with functions that have no parameters', () => {\n        const mockFn = jest.fn(() => 'result');\n        const wrappedFn = skipContext(mockFn);\n        const result = wrappedFn('context', 'queryFnContext');\n        expect(mockFn).toHaveBeenCalledWith();\n        expect(result).toBe('result');\n    });\n\n    it('should work with async functions', async () => {\n        const mockFn = jest.fn(async (arg: string) => `async-${arg}`);\n        const wrappedFn = skipContext(mockFn);\n        const result = await wrappedFn('context', 'queryFnContext', 'test');\n        expect(mockFn).toHaveBeenCalledWith('test');\n        expect(result).toBe('async-test');\n    });\n\n    it('should pass multiple arguments correctly', () => {\n        const mockFn = jest.fn(\n            (arg1: string, arg2: number, arg3: boolean) => `${arg1}-${arg2}-${arg3}`,\n        );\n        const wrappedFn = skipContext(mockFn);\n        const result = wrappedFn('context', 'queryFnContext', 'hello', 42, true);\n        expect(mockFn).toHaveBeenCalledWith('hello', 42, true);\n        expect(result).toBe('hello-42-true');\n    });\n});\n"],"mappings":"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","ignoreList":[]}

package/build/esm/core/utils/__tests__/withCancellation.test.js

@@ -0,0 +1,104 @@
+import { isAbortable, isCancellable, withCancellation } from '../withCancellation';
+describe('withCancellation', function () {
+  describe('isCancellable', function () {
+    it('should return true for objects with cancel method', function () {
+      var cancellable = {
+        cancel: jest.fn()
+      };
+      expect(isCancellable(cancellable)).toBe(true);
+    });
+    it('should return false for null', function () {
+      expect(isCancellable(null)).toBe(false);
+    });
+    it('should return false for objects without cancel method', function () {
+      expect(isCancellable({})).toBe(false);
+    });
+    it('should return false for objects with invalid cancel method', function () {
+      expect(isCancellable({
+        cancel: 'not a function'
+      })).toBe(false);
+    });
+  });
+  describe('isAbortable', function () {
+    it('should return true for objects with valid signal', function () {
+      var abortController = new AbortController();
+      var abortable = {
+        signal: abortController.signal
+      };
+      expect(isAbortable(abortable)).toBe(true);
+    });
+    it('should return false for null', function () {
+      expect(isAbortable(null)).toBe(false);
+    });
+    it('should return false for objects without signal', function () {
+      expect(isAbortable({})).toBe(false);
+    });
+    it('should return false for objects with invalid signal', function () {
+      expect(isAbortable({
+        signal: {}
+      })).toBe(false);
+    });
+  });
+  describe('withCancellation', function () {
+    it('should add abort listener when fetch returns cancellable and context is abortable', function () {
+      var mockCancel = jest.fn();
+      var cancellable = {
+        cancel: mockCancel
+      };
+      var abortController = new AbortController();
+      var fetchContext = {
+        signal: abortController.signal
+      };
+      var mockFetch = jest.fn().mockReturnValue(cancellable);
+      var dataSource = {
+        name: 'test',
+        fetch: mockFetch
+      };
+      var wrappedFetch = withCancellation(dataSource.fetch);
+      var result = wrappedFetch({}, fetchContext, {});
+      expect(mockFetch).toHaveBeenCalledWith({}, fetchContext, {});
+      expect(result).toBe(cancellable);
+      expect(mockCancel).not.toHaveBeenCalled();
+
+      // Simulate abort
+      abortController.abort();
+      expect(mockCancel).toHaveBeenCalled();
+    });
+    it('should not add abort listener when fetch returns non-cancellable', function () {
+      var abortController = new AbortController();
+      var fetchContext = {
+        signal: abortController.signal
+      };
+      var mockFetch = jest.fn().mockReturnValue('not cancellable');
+      var dataSource = {
+        name: 'test',
+        fetch: mockFetch
+      };
+      var wrappedFetch = withCancellation(dataSource.fetch);
+      var result = wrappedFetch({}, fetchContext, {});
+      expect(mockFetch).toHaveBeenCalledWith({}, fetchContext, {});
+      expect(result).toBe('not cancellable');
+
+      // No error should occur when aborting
+      abortController.abort();
+    });
+    it('should not add abort listener when context is not abortable', function () {
+      var mockCancel = jest.fn();
+      var cancellable = {
+        cancel: mockCancel
+      };
+      var fetchContext = {};
+      var mockFetch = jest.fn().mockReturnValue(cancellable);
+      var dataSource = {
+        name: 'test',
+        fetch: mockFetch
+      };
+      var wrappedFetch = withCancellation(dataSource.fetch);
+      var result = wrappedFetch({}, fetchContext, {});
+      expect(mockFetch).toHaveBeenCalledWith({}, fetchContext, {});
+      expect(result).toBe(cancellable);
+      expect(mockCancel).not.toHaveBeenCalled();
+    });
+  });
+});
+// #sourceMappingURL=withCancellation.test.js.map

package/build/esm/core/utils/__tests__/withCancellation.test.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isAbortable","isCancellable","withCancellation","describe","it","cancellable","cancel","jest","fn","expect","toBe","abortController","AbortController","abortable","signal","mockCancel","fetchContext","mockFetch","mockReturnValue","dataSource","name","fetch","wrappedFetch","result","toHaveBeenCalledWith","not","toHaveBeenCalled","abort"],"sources":["withCancellation.test.ts"],"sourcesContent":["import type {AnyDataSource} from '../../types/DataSource';\nimport type {Cancellable} from '../withCancellation';\nimport {isAbortable, isCancellable, withCancellation} from '../withCancellation';\n\ndescribe('withCancellation', () => {\n    describe('isCancellable', () => {\n        it('should return true for objects with cancel method', () => {\n            const cancellable: Cancellable = {\n                cancel: jest.fn(),\n            };\n            expect(isCancellable(cancellable)).toBe(true);\n        });\n\n        it('should return false for null', () => {\n            expect(isCancellable(null)).toBe(false);\n        });\n\n        it('should return false for objects without cancel method', () => {\n            expect(isCancellable({})).toBe(false);\n        });\n\n        it('should return false for objects with invalid cancel method', () => {\n            expect(isCancellable({cancel: 'not a function'})).toBe(false);\n        });\n    });\n\n    describe('isAbortable', () => {\n        it('should return true for objects with valid signal', () => {\n            const abortController = new AbortController();\n            const abortable = {signal: abortController.signal};\n            expect(isAbortable(abortable)).toBe(true);\n        });\n\n        it('should return false for null', () => {\n            expect(isAbortable(null)).toBe(false);\n        });\n\n        it('should return false for objects without signal', () => {\n            expect(isAbortable({})).toBe(false);\n        });\n\n        it('should return false for objects with invalid signal', () => {\n            expect(isAbortable({signal: {}})).toBe(false);\n        });\n    });\n\n    describe('withCancellation', () => {\n        it('should add abort listener when fetch returns cancellable and context is abortable', () => {\n            const mockCancel = jest.fn();\n            const cancellable: Cancellable = {\n                cancel: mockCancel,\n            };\n\n            const abortController = new AbortController();\n            const fetchContext = {signal: abortController.signal};\n\n            const mockFetch = jest.fn().mockReturnValue(cancellable);\n            const dataSource: AnyDataSource = {\n                name: 'test',\n                fetch: mockFetch,\n            };\n\n            const wrappedFetch = withCancellation(dataSource.fetch);\n            const result = wrappedFetch({}, fetchContext, {});\n\n            expect(mockFetch).toHaveBeenCalledWith({}, fetchContext, {});\n            expect(result).toBe(cancellable);\n            expect(mockCancel).not.toHaveBeenCalled();\n\n            // Simulate abort\n            abortController.abort();\n            expect(mockCancel).toHaveBeenCalled();\n        });\n\n        it('should not add abort listener when fetch returns non-cancellable', () => {\n            const abortController = new AbortController();\n            const fetchContext = {signal: abortController.signal};\n\n            const mockFetch = jest.fn().mockReturnValue('not cancellable');\n            const dataSource: AnyDataSource = {\n                name: 'test',\n                fetch: mockFetch,\n            };\n\n            const wrappedFetch = withCancellation(dataSource.fetch);\n            const result = wrappedFetch({}, fetchContext, {});\n\n            expect(mockFetch).toHaveBeenCalledWith({}, fetchContext, {});\n            expect(result).toBe('not cancellable');\n\n            // No error should occur when aborting\n            abortController.abort();\n        });\n\n        it('should not add abort listener when context is not abortable', () => {\n            const mockCancel = jest.fn();\n            const cancellable: Cancellable = {\n                cancel: mockCancel,\n            };\n\n            const fetchContext = {};\n\n            const mockFetch = jest.fn().mockReturnValue(cancellable);\n            const dataSource: AnyDataSource = {\n                name: 'test',\n                fetch: mockFetch,\n            };\n\n            const wrappedFetch = withCancellation(dataSource.fetch);\n            const result = wrappedFetch({}, fetchContext, {});\n\n            expect(mockFetch).toHaveBeenCalledWith({}, fetchContext, {});\n            expect(result).toBe(cancellable);\n            expect(mockCancel).not.toHaveBeenCalled();\n        });\n    });\n});\n"],"mappings":"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","ignoreList":[]}

package/build/esm/core/utils/__tests__/withCatch.test.js

@@ -0,0 +1,205 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _regeneratorRuntime from "@babel/runtime/helpers/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import { withCatch } from '../withCatch';
+describe('withCatch', function () {
+  it('should return the result of the fetch function when it succeeds', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var mockFetch, mockErrorHandler, safeFetch, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          mockFetch = jest.fn().mockResolvedValue({
+            data: 'success'
+          });
+          mockErrorHandler = jest.fn().mockReturnValue({
+            error: 'handled'
+          });
+          safeFetch = withCatch(mockFetch, mockErrorHandler);
+          _context.next = 5;
+          return safeFetch('arg1', 42);
+        case 5:
+          result = _context.sent;
+          expect(mockFetch).toHaveBeenCalledWith('arg1', 42);
+          expect(mockErrorHandler).not.toHaveBeenCalled();
+          expect(result).toEqual({
+            data: 'success'
+          });
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('should call the error handler when the fetch function fails', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    var error, mockFetch, mockErrorHandler, safeFetch, result;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          error = new Error('fetch failed');
+          mockFetch = jest.fn().mockRejectedValue(error);
+          mockErrorHandler = jest.fn().mockReturnValue({
+            error: 'handled'
+          });
+          safeFetch = withCatch(mockFetch, mockErrorHandler);
+          _context2.next = 6;
+          return safeFetch('arg1', 42);
+        case 6:
+          result = _context2.sent;
+          expect(mockFetch).toHaveBeenCalledWith('arg1', 42);
+          expect(mockErrorHandler).toHaveBeenCalledWith(error);
+          expect(result).toEqual({
+            error: 'handled'
+          });
+        case 10:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('should work with functions that take no parameters', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+    var mockFetch, mockErrorHandler, safeFetch, result;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          mockFetch = jest.fn().mockResolvedValue({
+            data: 'success'
+          });
+          mockErrorHandler = jest.fn().mockReturnValue({
+            error: 'handled'
+          });
+          safeFetch = withCatch(mockFetch, mockErrorHandler);
+          _context3.next = 5;
+          return safeFetch();
+        case 5:
+          result = _context3.sent;
+          expect(mockFetch).toHaveBeenCalledWith();
+          expect(mockErrorHandler).not.toHaveBeenCalled();
+          expect(result).toEqual({
+            data: 'success'
+          });
+        case 9:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('should work with functions that take multiple parameters', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+    var mockFetch, mockErrorHandler, safeFetch, result;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          mockFetch = jest.fn().mockResolvedValue({
+            data: 'success'
+          });
+          mockErrorHandler = jest.fn().mockReturnValue({
+            error: 'handled'
+          });
+          safeFetch = withCatch(mockFetch, mockErrorHandler);
+          _context4.next = 5;
+          return safeFetch('arg1', 42, true, {
+            complex: 'object'
+          });
+        case 5:
+          result = _context4.sent;
+          expect(mockFetch).toHaveBeenCalledWith('arg1', 42, true, {
+            complex: 'object'
+          });
+          expect(mockErrorHandler).not.toHaveBeenCalled();
+          expect(result).toEqual({
+            data: 'success'
+          });
+        case 9:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('should handle error handlers that return promises', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+    var error, mockFetch, mockErrorHandler, safeFetch, result;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          error = new Error('fetch failed');
+          mockFetch = jest.fn().mockRejectedValue(error);
+          mockErrorHandler = jest.fn().mockResolvedValue({
+            error: 'async handled'
+          });
+          safeFetch = withCatch(mockFetch, mockErrorHandler);
+          _context5.next = 6;
+          return safeFetch('arg1');
+        case 6:
+          result = _context5.sent;
+          expect(mockFetch).toHaveBeenCalledWith('arg1');
+          expect(mockErrorHandler).toHaveBeenCalledWith(error);
+          expect(result).toEqual({
+            error: 'async handled'
+          });
+        case 10:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it('should preserve the type of the fetch function return value', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+    var mockFetch, mockErrorHandler, safeFetch, result, userName;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          mockFetch = jest.fn().mockResolvedValue({
+            id: 1,
+            name: 'John Doe'
+          });
+          mockErrorHandler = jest.fn().mockReturnValue(null);
+          safeFetch = withCatch(mockFetch, mockErrorHandler);
+          _context6.next = 5;
+          return safeFetch('user1');
+        case 5:
+          result = _context6.sent;
+          expect(result).toEqual({
+            id: 1,
+            name: 'John Doe'
+          });
+          // TypeScript should recognize result as User | null
+          if (result !== null) {
+            // This should compile without errors
+            userName = result.name;
+            expect(userName).toBe('John Doe');
+          }
+        case 8:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('should preserve the type of the error handler return value', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+    var error, mockFetch, mockErrorHandler, safeFetch, result, errorCode;
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          error = new Error('fetch failed');
+          mockFetch = jest.fn().mockRejectedValue(error);
+          mockErrorHandler = jest.fn().mockReturnValue({
+            code: 500,
+            message: 'Internal Server Error'
+          });
+          safeFetch = withCatch(mockFetch, mockErrorHandler);
+          _context7.next = 6;
+          return safeFetch('user1');
+        case 6:
+          result = _context7.sent;
+          expect(mockErrorHandler).toHaveBeenCalledWith(error);
+
+          // TypeScript should recognize result as unknown | ErrorResponse
+          if (_typeof(result) === 'object' && result !== null && 'code' in result) {
+            // This should compile without errors
+            errorCode = result.code;
+            expect(errorCode).toBe(500);
+          }
+        case 9:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+});
+// #sourceMappingURL=withCatch.test.js.map

package/build/esm/core/utils/__tests__/withCatch.test.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["withCatch","describe","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee","mockFetch","mockErrorHandler","safeFetch","result","wrap","_callee$","_context","prev","next","jest","fn","mockResolvedValue","data","mockReturnValue","error","sent","expect","toHaveBeenCalledWith","not","toHaveBeenCalled","toEqual","stop","_callee2","_callee2$","_context2","Error","mockRejectedValue","_callee3","_callee3$","_context3","_callee4","_callee4$","_context4","complex","_callee5","_callee5$","_context5","_callee6","userName","_callee6$","_context6","id","name","toBe","_callee7","errorCode","_callee7$","_context7","code","message","_typeof"],"sources":["withCatch.test.ts"],"sourcesContent":["import {withCatch} from '../withCatch';\n\ndescribe('withCatch', () => {\n    it('should return the result of the fetch function when it succeeds', async () => {\n        const mockFetch = jest.fn().mockResolvedValue({data: 'success'});\n        const mockErrorHandler = jest.fn().mockReturnValue({error: 'handled'});\n\n        const safeFetch = withCatch(mockFetch, mockErrorHandler);\n        const result = await safeFetch('arg1', 42);\n\n        expect(mockFetch).toHaveBeenCalledWith('arg1', 42);\n        expect(mockErrorHandler).not.toHaveBeenCalled();\n        expect(result).toEqual({data: 'success'});\n    });\n\n    it('should call the error handler when the fetch function fails', async () => {\n        const error = new Error('fetch failed');\n        const mockFetch = jest.fn().mockRejectedValue(error);\n        const mockErrorHandler = jest.fn().mockReturnValue({error: 'handled'});\n\n        const safeFetch = withCatch(mockFetch, mockErrorHandler);\n        const result = await safeFetch('arg1', 42);\n\n        expect(mockFetch).toHaveBeenCalledWith('arg1', 42);\n        expect(mockErrorHandler).toHaveBeenCalledWith(error);\n        expect(result).toEqual({error: 'handled'});\n    });\n\n    it('should work with functions that take no parameters', async () => {\n        const mockFetch = jest.fn().mockResolvedValue({data: 'success'});\n        const mockErrorHandler = jest.fn().mockReturnValue({error: 'handled'});\n\n        const safeFetch = withCatch(mockFetch, mockErrorHandler);\n        const result = await safeFetch();\n\n        expect(mockFetch).toHaveBeenCalledWith();\n        expect(mockErrorHandler).not.toHaveBeenCalled();\n        expect(result).toEqual({data: 'success'});\n    });\n\n    it('should work with functions that take multiple parameters', async () => {\n        const mockFetch = jest.fn().mockResolvedValue({data: 'success'});\n        const mockErrorHandler = jest.fn().mockReturnValue({error: 'handled'});\n\n        const safeFetch = withCatch(mockFetch, mockErrorHandler);\n        const result = await safeFetch('arg1', 42, true, {complex: 'object'});\n\n        expect(mockFetch).toHaveBeenCalledWith('arg1', 42, true, {complex: 'object'});\n        expect(mockErrorHandler).not.toHaveBeenCalled();\n        expect(result).toEqual({data: 'success'});\n    });\n\n    it('should handle error handlers that return promises', async () => {\n        const error = new Error('fetch failed');\n        const mockFetch = jest.fn().mockRejectedValue(error);\n        const mockErrorHandler = jest.fn().mockResolvedValue({error: 'async handled'});\n\n        const safeFetch = withCatch(mockFetch, mockErrorHandler);\n        const result = await safeFetch('arg1');\n\n        expect(mockFetch).toHaveBeenCalledWith('arg1');\n        expect(mockErrorHandler).toHaveBeenCalledWith(error);\n        expect(result).toEqual({error: 'async handled'});\n    });\n\n    it('should preserve the type of the fetch function return value', async () => {\n        interface User {\n            id: number;\n            name: string;\n        }\n\n        const mockFetch = jest.fn().mockResolvedValue({\n            id: 1,\n            name: 'John Doe',\n        } as User);\n\n        const mockErrorHandler = jest.fn().mockReturnValue(null);\n\n        const safeFetch = withCatch<[string], User, null>(mockFetch, mockErrorHandler);\n        const result = await safeFetch('user1');\n\n        expect(result).toEqual({id: 1, name: 'John Doe'});\n        // TypeScript should recognize result as User | null\n        if (result !== null) {\n            // This should compile without errors\n            const userName = result.name;\n            expect(userName).toBe('John Doe');\n        }\n    });\n\n    it('should preserve the type of the error handler return value', async () => {\n        interface ErrorResponse {\n            code: number;\n            message: string;\n        }\n\n        const error = new Error('fetch failed');\n        const mockFetch = jest.fn<Promise<unknown>, [string]>().mockRejectedValue(error);\n\n        const mockErrorHandler = jest.fn().mockReturnValue({\n            code: 500,\n            message: 'Internal Server Error',\n        } as ErrorResponse);\n\n        const safeFetch = withCatch<[string], unknown, ErrorResponse>(mockFetch, mockErrorHandler);\n        const result = await safeFetch('user1');\n\n        expect(mockErrorHandler).toHaveBeenCalledWith(error);\n\n        // TypeScript should recognize result as unknown | ErrorResponse\n        if (typeof result === 'object' && result !== null && 'code' in result) {\n            // This should compile without errors\n            const errorCode = (result as ErrorResponse).code;\n            expect(errorCode).toBe(500);\n        }\n    });\n});\n"],"mappings":"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","ignoreList":[]}

package/build/esm/core/utils/withCatch.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Creates a wrapper around a function that safely handles errors using a provided error handler.
+ *
+ * This utility function enhances a Promise-returning function by adding standardized error handling.
+ * It catches any errors thrown by the original function and processes them through the provided
+ * error handler, allowing for consistent error management across the application.
+ *
+ * @template TArgs - The argument types of the original function
+ * @template TFetchReturnType - The return type of the original function's Promise
+ * @template TCatchReturnType - The return type of the error handler function
+ *
+ * @param fetchFn - The original function that returns a Promise
+ * @param onCatchFn - The error handler function that processes any caught errors
+ *
+ * @returns A new function with the same signature as the original function,
+ *          but with error handling applied. The returned function will resolve to either
+ *          the successful result of the original function or the result of the error handler.
+ *
+ * @example
+ * // Basic usage with a string parameter
+ * const fetchUser = withCatch(
+ *   someFetchFunction,
+ *   (error) => ({ error: true, message: error.message })
+ * );
+ */
+export declare function withCatch<TArgs extends unknown[], TFetchReturnType, TCatchReturnType>(fetchFn: (...args: TArgs) => Promise<TFetchReturnType>, onCatchFn: (reason: unknown) => TCatchReturnType): (...args: TArgs) => Promise<TFetchReturnType | TCatchReturnType>;

package/build/esm/core/utils/withCatch.js

@@ -0,0 +1,31 @@
+/**
+ * Creates a wrapper around a function that safely handles errors using a provided error handler.
+ *
+ * This utility function enhances a Promise-returning function by adding standardized error handling.
+ * It catches any errors thrown by the original function and processes them through the provided
+ * error handler, allowing for consistent error management across the application.
+ *
+ * @template TArgs - The argument types of the original function
+ * @template TFetchReturnType - The return type of the original function's Promise
+ * @template TCatchReturnType - The return type of the error handler function
+ *
+ * @param fetchFn - The original function that returns a Promise
+ * @param onCatchFn - The error handler function that processes any caught errors
+ *
+ * @returns A new function with the same signature as the original function,
+ *          but with error handling applied. The returned function will resolve to either
+ *          the successful result of the original function or the result of the error handler.
+ *
+ * @example
+ * // Basic usage with a string parameter
+ * const fetchUser = withCatch(
+ *   someFetchFunction,
+ *   (error) => ({ error: true, message: error.message })
+ * );
+ */
+export function withCatch(fetchFn, onCatchFn) {
+  return function () {
+    return fetchFn.apply(void 0, arguments)["catch"](onCatchFn);
+  };
+}
+// #sourceMappingURL=withCatch.js.map

package/build/esm/core/utils/withCatch.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["withCatch","fetchFn","onCatchFn","apply","arguments"],"sources":["withCatch.ts"],"sourcesContent":["/**\n * Creates a wrapper around a function that safely handles errors using a provided error handler.\n *\n * This utility function enhances a Promise-returning function by adding standardized error handling.\n * It catches any errors thrown by the original function and processes them through the provided\n * error handler, allowing for consistent error management across the application.\n *\n * @template TArgs - The argument types of the original function\n * @template TFetchReturnType - The return type of the original function's Promise\n * @template TCatchReturnType - The return type of the error handler function\n *\n * @param fetchFn - The original function that returns a Promise\n * @param onCatchFn - The error handler function that processes any caught errors\n *\n * @returns A new function with the same signature as the original function,\n *          but with error handling applied. The returned function will resolve to either\n *          the successful result of the original function or the result of the error handler.\n *\n * @example\n * // Basic usage with a string parameter\n * const fetchUser = withCatch(\n *   someFetchFunction,\n *   (error) => ({ error: true, message: error.message })\n * );\n */\nexport function withCatch<TArgs extends unknown[], TFetchReturnType, TCatchReturnType>(\n    fetchFn: (...args: TArgs) => Promise<TFetchReturnType>,\n    onCatchFn: (reason: unknown) => TCatchReturnType,\n): (...args: TArgs) => Promise<TFetchReturnType | TCatchReturnType> {\n    return (...args) => {\n        return fetchFn(...args).catch(onCatchFn) as Promise<TFetchReturnType | TCatchReturnType>;\n    };\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,SAASA,CACrBC,OAAsD,EACtDC,SAAgD,EACgB;EAChE,OAAO,YAAa;IAChB,OAAOD,OAAO,CAAAE,KAAA,SAAAC,SAAQ,CAAC,SAAM,CAACF,SAAS,CAAC;EAC5C,CAAC;AACL","ignoreList":[]}