@ama-sdk/core 11.0.0-next.2 → 11.0.0-prerelease.10

package/README.md

@@ -9,6 +9,7 @@ Please refer to the [ama-sdk-schematics](../schematics/README.md) package for ge
 
 ## Available plugins
 
+- [abort](https://github.com/AmadeusITGroup/otter/tree/main/packages/%40ama-sdk/core/src/plugins/abort)
 - [additional-params](https://github.com/AmadeusITGroup/otter/tree/main/packages/%40ama-sdk/core/src/plugins/additional-params)
 - [api-configuration-override](https://github.com/AmadeusITGroup/otter/tree/main/packages/%40ama-sdk/core/src/plugins/api-configuration-override)
 - [api-key](https://github.com/AmadeusITGroup/otter/tree/main/packages/%40ama-sdk/core/src/plugins/api-key)
@@ -69,3 +70,15 @@ function petApiFactory() {
 ```
 
 > *Note*: Adding a third-party logging service is optional. If undefined, the fallback is the console logger.
+
+### CLI
+
+This package also comes with CLI scripts that can facilitate the upgrade and publication of an SDK. 
+Use --help on each command for more information
+
+| Script                      | Description                                                                                    |
+|-----------------------------|------------------------------------------------------------------------------------------------|
+| amasdk-clear-index          | Remove the index files that are no longer necessary after the deletion of the associated model |
+| amasdk-files-pack           | Prepare the dist folder for publication                                                        |
+| amasdk-update-spec-from-npm | Update the OpenAPI spec from an NPM package                                                    |
+

package/cjs/fwk/core/base-api-constructor.js

@@ -8,6 +8,10 @@ Object.defineProperty(exports, "isConstructorObject", {
         return isConstructorObject;
     }
 });
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function isConstructorObject(args) {
-    return !!args && args.length === 1 && !!args[0] && typeof args[0] === 'object';
+    return !!args && args.length === 1 && !!args[0] && _type_of(args[0]) === 'object';
 }

package/cjs/fwk/index.js

@@ -11,6 +11,7 @@ _export_star(require("./errors"), exports);
 _export_star(require("./ignore-enum.type"), exports);
 _export_star(require("./logger"), exports);
 _export_star(require("./mocks/index"), exports);
+_export_star(require("./open-api-tools-configuration"), exports);
 _export_star(require("./Reviver"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/cjs/fwk/open-api-tools-configuration.js

@@ -0,0 +1,4 @@
+/** Configuration of an Open API generator */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/cjs/plugins/abort/abort.fetch.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AbortFetch", {
+    enumerable: true,
+    get: function() {
+        return AbortFetch;
+    }
+});
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var isPromise = function(result) {
+    if ((typeof result === "undefined" ? "undefined" : _type_of(result)) !== 'object') {
+        return false;
+    }
+    return true;
+};
+var AbortFetch = /*#__PURE__*/ function() {
+    "use strict";
+    function AbortFetch(abortCallback) {
+        _class_call_check(this, AbortFetch);
+        _define_property(this, "abortCallback", void 0);
+        this.abortCallback = abortCallback;
+    }
+    _create_class(AbortFetch, [
+        {
+            key: "load",
+            value: /** @inheritDoc */ function load(context) {
+                var _this = this;
+                return {
+                    transform: function(fetchCall) {
+                        var abortCallbackResult = _this.abortCallback();
+                        if (isPromise(abortCallbackResult)) {
+                            void abortCallbackResult.then(function(res) {
+                                var _context_controller;
+                                return res && ((_context_controller = context.controller) === null || _context_controller === void 0 ? void 0 : _context_controller.abort());
+                            });
+                        } else if (abortCallbackResult) {
+                            var _context_controller;
+                            (_context_controller = context.controller) === null || _context_controller === void 0 ? void 0 : _context_controller.abort();
+                        }
+                        return fetchCall;
+                    }
+                };
+            }
+        }
+    ]);
+    return AbortFetch;
+}();

package/cjs/plugins/abort/abort.spec.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _abortfetch = require("./abort.fetch");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+describe('Abort Plugin', function() {
+    it('should trigger the callback', /*#__PURE__*/ _async_to_generator(function() {
+        var fn, plugin, runner;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    fn = jest.fn();
+                    plugin = new _abortfetch.AbortFetch(fn);
+                    runner = plugin.load({});
+                    return [
+                        4,
+                        runner.transform(Promise.resolve())
+                    ];
+                case 1:
+                    _state.sent();
+                    expect(fn).toHaveBeenCalled();
+                    return [
+                        2
+                    ];
+            }
+        });
+    }));
+    it('should trigger abort signal if true', /*#__PURE__*/ _async_to_generator(function() {
+        var defaultContext, fn, plugin, runner;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    defaultContext = {
+                        controller: {
+                            abort: jest.fn()
+                        }
+                    };
+                    fn = jest.fn().mockResolvedValue(true);
+                    plugin = new _abortfetch.AbortFetch(fn);
+                    runner = plugin.load(defaultContext);
+                    return [
+                        4,
+                        runner.transform(Promise.resolve())
+                    ];
+                case 1:
+                    _state.sent();
+                    expect(defaultContext.controller.abort).toHaveBeenCalled();
+                    return [
+                        2
+                    ];
+            }
+        });
+    }));
+    it('should not trigger abort signal if false', /*#__PURE__*/ _async_to_generator(function() {
+        var defaultContext, fn, plugin, runner;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    defaultContext = {
+                        controller: {
+                            abort: jest.fn()
+                        }
+                    };
+                    fn = jest.fn().mockResolvedValue(false);
+                    plugin = new _abortfetch.AbortFetch(fn);
+                    runner = plugin.load(defaultContext);
+                    return [
+                        4,
+                        runner.transform(Promise.resolve())
+                    ];
+                case 1:
+                    _state.sent();
+                    expect(defaultContext.controller.abort).not.toHaveBeenCalled();
+                    return [
+                        2
+                    ];
+            }
+        });
+    }));
+});

package/cjs/plugins/abort/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./abort.fetch"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/cjs/plugins/index.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./abort/index"), exports);
 _export_star(require("./additional-params/index"), exports);
 _export_star(require("./api-configuration-override/index"), exports);
 _export_star(require("./api-key/index"), exports);
 _export_star(require("./bot-protection-fingerprint/index"), exports);
+_export_star(require("./client-facts/index"), exports);
 _export_star(require("./concurrent/index"), exports);
 _export_star(require("./core/index"), exports);
-_export_star(require("./client-facts/index"), exports);
 _export_star(require("./custom-info/index"), exports);
 _export_star(require("./exception/index"), exports);
 _export_star(require("./fetch-cache/index"), exports);
@@ -24,9 +25,9 @@ _export_star(require("./reviver/index"), exports);
 _export_star(require("./session-id/index"), exports);
 _export_star(require("./si-token/index"), exports);
 _export_star(require("./simple-api-key-authentication/index"), exports);
+_export_star(require("./timeout/index"), exports);
 _export_star(require("./url-rewrite/index"), exports);
 _export_star(require("./wait-for/index"), exports);
-_export_star(require("./timeout/index"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/cjs/utils/generators.js

@@ -0,0 +1,25 @@
+// TODO: Change to `openapi` in v11 (ref: #1745)
+/** Name of the specification file copied locally (without extension) */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    LOCAL_SPEC_FILENAME: function() {
+        return LOCAL_SPEC_FILENAME;
+    },
+    SPEC_JSON_EXTENSION: function() {
+        return SPEC_JSON_EXTENSION;
+    },
+    SPEC_YAML_EXTENSION: function() {
+        return SPEC_YAML_EXTENSION;
+    }
+});
+var LOCAL_SPEC_FILENAME = 'swagger-spec';
+var SPEC_YAML_EXTENSION = 'yaml';
+var SPEC_JSON_EXTENSION = 'yaml';

package/cjs/utils/index.js

@@ -8,6 +8,7 @@ _export_star(require("./ie11"), exports);
 _export_star(require("./json-token"), exports);
 _export_star(require("./mime-types"), exports);
 _export_star(require("./generic-api"), exports);
+_export_star(require("./generators"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/cli/clear-index.cjs

@@ -4,9 +4,18 @@
  * Remove deleted models' exports
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const minimist = require("minimist");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const argv = minimist(process.argv.slice(2));
+const { help } = argv;
 const baseDir = (0, node_path_1.resolve)(process.cwd(), 'src', 'models', 'base');
+if (help) {
+    console.log(`Remove the index files that are no longer necessary after the deletion of the associated model.
+  Usage: amasdk-clear-index
+  `);
+    process.exit(0);
+}
 void (async () => {
     const models = await node_fs_1.promises.readdir(baseDir);
     const shouldRemoveModels = (await Promise.all(models

package/cli/files-pack.cjs

@@ -12,7 +12,16 @@ const globby = require("globby");
 const argv = minimist(process.argv.slice(2));
 const distFolder = argv.dist || 'dist';
 const baseDir = argv.cwd && path.resolve(process.cwd(), argv.cwd) || process.cwd();
-const { watch, noExports } = argv;
+const { help, watch, noExports } = argv;
+if (help) {
+    console.log(`Prepare the dist folder for publication. This will copy necessary files from src and update the exports in package.json.
+  Usage: amasdk-files-pack [--exports] [--watch]
+
+    --exports    Update the exports in package.json. (Default: true)
+    --watch      Watch for files changes and run the updates
+  `);
+    process.exit(0);
+}
 const files = [
     { glob: 'README.md', cwdForCopy: baseDir },
     { glob: 'LICENSE', cwdForCopy: baseDir },
@@ -66,10 +75,12 @@ void (async () => {
     const copies = files.map(async ({ glob, cwdForCopy }) => {
         return watch ?
             Promise.resolve().then(() => require('chokidar')).then((chokidar) => chokidar.watch(glob, { cwd: baseDir }))
-                .then((watcher) => watcher.on('all', (event, file) => {
+                .then((watcher) => watcher.on('all', async (event, file) => {
                 if (event !== 'unlink' && event !== 'unlinkDir') {
                     copyToDist(file, cwdForCopy);
-                    return updateExports();
+                    if (!noExports) {
+                        await updateExports();
+                    }
                 }
             })) :
             globby.sync(glob)

package/cli/update-spec-from-npm.cjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+"use strict";
+/*
+ * Update the OpenAPI spec from an NPM package
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const minimist = require("minimist");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const core_1 = require("@ama-sdk/core");
+const argv = minimist(process.argv.slice(2));
+const packageName = argv._[0];
+const { help, output, 'package-path': packagePath, quiet } = argv;
+const openApiConfigDefaultPath = './openapitools.json';
+const noop = () => undefined;
+const logger = quiet ? { error: noop, warn: noop, log: noop, info: noop, debug: noop } : console;
+const SPEC_YML_EXTENSION = 'yml';
+const DEFAULT_SPEC_EXPORT_PATH_IN_NPM_MODULE = 'openapi';
+const supportedExtensions = [core_1.SPEC_JSON_EXTENSION, core_1.SPEC_YAML_EXTENSION, SPEC_YML_EXTENSION];
+if (help) {
+    // eslint-disable-next-line no-console
+    console.log(`This script can be used to update your local spec file from a given locally installed npm package.
+  Usage: amasdk-update-spec-from-npm <package-name> [--package-path] [--output] [--quiet]
+
+    package-name      The full identifier of the npm package (e.g. @my-scope/my-package)
+    --package-path    The relative path inside the npm package where to find the spec file (default: './openapi.yml')
+    --output          The path where the spec file should be copied (default: './${core_1.LOCAL_SPEC_FILENAME}.${core_1.SPEC_YAML_EXTENSION}')
+    --quiet           Don't log anything
+  `);
+    process.exit(0);
+}
+if (!packageName) {
+    logger.error('Need to provide packageName, use `amasdk-update-spec-from-npm --help` for more information');
+    process.exit(-1);
+}
+void (async () => {
+    let specSourcePath;
+    const appRequire = (0, node_module_1.createRequire)(node_path_1.posix.join(process.cwd(), 'package.json'));
+    const packageJsonPath = appRequire.resolve(`${packageName}/package.json`);
+    if (!packagePath) {
+        const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonPath, { encoding: 'utf8' }));
+        const exportMatcher = new RegExp(`^\\./${DEFAULT_SPEC_EXPORT_PATH_IN_NPM_MODULE}\\.(?:${supportedExtensions.join('|')})$`);
+        const matchingExport = packageJson.exports && Object.keys(packageJson.exports).find((exportPath) => exportMatcher.test(exportPath));
+        if (matchingExport) {
+            specSourcePath = appRequire.resolve(node_path_1.posix.join(packageName, matchingExport));
+        }
+    }
+    else {
+        specSourcePath = packageJsonPath.replace(/package.json$/, packagePath);
+    }
+    if (!specSourcePath || !(0, node_fs_1.existsSync)(specSourcePath)) {
+        logger.error(`Unable to find source spec from ${packageName}, please make sure it is correctly exported in package.json`);
+        process.exit(-2);
+    }
+    let specDestinationPath = output;
+    if (!specDestinationPath) {
+        let specSourceExtension = (0, node_path_1.extname)(specSourcePath);
+        if (specSourceExtension === `.${SPEC_YML_EXTENSION}`) {
+            specSourceExtension = `.${core_1.SPEC_YAML_EXTENSION}`;
+        }
+        specDestinationPath = `./${core_1.LOCAL_SPEC_FILENAME}${specSourceExtension}`;
+        if ((0, node_fs_1.existsSync)(openApiConfigDefaultPath)) {
+            const openApiConfig = JSON.parse(await (0, promises_1.readFile)(openApiConfigDefaultPath, { encoding: 'utf8' }));
+            const generators = Object.values(openApiConfig['generator-cli']?.generators ?? {});
+            if (generators.length === 1 && generators[0].inputSpec && (0, node_path_1.extname)(generators[0].inputSpec) === specSourceExtension) {
+                specDestinationPath = generators[0].inputSpec;
+            }
+        }
+    }
+    logger.info(`Updating spec file from "${specSourcePath}" to "${specDestinationPath}" (CWD: "${process.cwd()}")`);
+    await (0, promises_1.copyFile)(specSourcePath, specDestinationPath);
+})();
+//# sourceMappingURL=update-spec-from-npm.cjs.map

package/cli/update-spec-from-npm.d.cts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=update-spec-from-npm.d.cts.map

package/cli/update-spec-from-npm.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-spec-from-npm.d.cts","sourceRoot":"","sources":["../../cli/update-spec-from-npm.cts"],"names":[],"mappings":""}

package/esm2015/fwk/core/base-api-constructor.js

@@ -1,6 +1,10 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 /**
  * Determine if object passed to the constructor is valid
  * @param args
  */ export function isConstructorObject(args) {
-    return !!args && args.length === 1 && !!args[0] && typeof args[0] === 'object';
+    return !!args && args.length === 1 && !!args[0] && _type_of(args[0]) === 'object';
 }

package/esm2015/fwk/index.js

@@ -7,4 +7,5 @@ export * from './errors';
 export * from './ignore-enum.type';
 export * from './logger';
 export * from './mocks/index';
+export * from './open-api-tools-configuration';
 export * from './Reviver';

package/esm2015/fwk/open-api-tools-configuration.js

@@ -0,0 +1 @@
+/** Configuration of an Open API generator */ /** Global configuration of Open API Tools */ export { };

package/esm2015/plugins/abort/abort.fetch.js

@@ -0,0 +1,74 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var isPromise = function(result) {
+    if ((typeof result === "undefined" ? "undefined" : _type_of(result)) !== 'object') {
+        return false;
+    }
+    return true;
+};
+/** Plugin to abort a Fetch request */ export var AbortFetch = /*#__PURE__*/ function() {
+    "use strict";
+    function AbortFetch(abortCallback) {
+        _class_call_check(this, AbortFetch);
+        _define_property(this, "abortCallback", void 0);
+        this.abortCallback = abortCallback;
+    }
+    _create_class(AbortFetch, [
+        {
+            key: "load",
+            value: /** @inheritDoc */ function load(context) {
+                var _this = this;
+                return {
+                    transform: function(fetchCall) {
+                        var abortCallbackResult = _this.abortCallback();
+                        if (isPromise(abortCallbackResult)) {
+                            void abortCallbackResult.then(function(res) {
+                                var _context_controller;
+                                return res && ((_context_controller = context.controller) === null || _context_controller === void 0 ? void 0 : _context_controller.abort());
+                            });
+                        } else if (abortCallbackResult) {
+                            var _context_controller;
+                            (_context_controller = context.controller) === null || _context_controller === void 0 ? void 0 : _context_controller.abort();
+                        }
+                        return fetchCall;
+                    }
+                };
+            }
+        }
+    ]);
+    return AbortFetch;
+}();