@savafeed/cart-api-sdk 1.0.11 → 1.0.13

package/dist/cart-api-sdk.cjs.js

@@ -1,786 +1,7 @@
 'use strict';
 
-require('reflect-metadata');
-
-class TypeSpecifier {
-    static isClass(input) {
-        return (!TypeSpecifier.isFunction(input) &&
-            !TypeSpecifier.isFunctionByTryCall(input) &&
-            TypeSpecifier.isClassByStringLiteral(input));
-    }
-    static isClassByStringLiteral(input) {
-        const functionString = input.toString();
-        return !!functionString.startsWith('class');
-    }
-    static isFunction(input) {
-        return typeof input !== 'function';
-    }
-    static isFunctionByTryCall(input) {
-        try {
-            input();
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}
-
-class ModuleRef {
-    parentContainer;
-    module;
-    controllers = new Map();
-    providers = new Map();
-    constructor(parentContainer, module) {
-        this.parentContainer = parentContainer;
-        this.module = module;
-        this["registerProviders" /* E_REGISTER_CALL_ORDER.first */]();
-        this["registerControllers" /* E_REGISTER_CALL_ORDER.second */]();
-    }
-    ;
-    registerProviders() {
-        const providers = this.module.providers;
-        if (!providers)
-            return;
-        for (const provider of providers) {
-            if (this.providers.has(provider))
-                continue;
-            const dependencyTokens = Reflect.getMetadata("design:paramtypes" /* E_TOKENS.DESIGN_PARAMTYPES */, provider);
-            const dependencies = [];
-            dependencyTokens?.forEach((dependencyToken, index) => {
-                if (!TypeSpecifier.isClass(dependencyToken)) {
-                    const injectTokens = Reflect.getMetadata("inject:tokens" /* E_TOKENS.INJECT_TOKENS */, provider) || [];
-                    const injectToken = injectTokens.find((injectObject) => injectObject.index === index);
-                    if (!this.parentContainer.providers.has(injectToken?.token))
-                        return console.warn(`[WARN] (Inject) ${injectToken} is not provide in`, this.parentContainer);
-                    dependencies.push(this.parentContainer.providers.get(injectToken?.token));
-                }
-                else {
-                    if (!this.parentContainer.providers.has(dependencyToken))
-                        return console.warn(`[WARN] (Injectable) ${dependencyToken} is not provide in`, this.parentContainer);
-                    dependencies.push(this.parentContainer.providers.get(dependencyToken));
-                }
-            });
-            let providerToken;
-            let providerInstance;
-            if (provider?.token) {
-                const injectProvider = this.getInjectProviderWithInstance(provider);
-                if (!injectProvider)
-                    return console.warn(`[WARN] Provider type is not Inject. ${provider.token} is not provide in`, this.parentContainer);
-                providerToken = injectProvider.token;
-                providerInstance = injectProvider.instance;
-                Reflect.defineMetadata(providerToken, providerInstance, this.module);
-            }
-            else {
-                providerToken = provider;
-                providerInstance = new provider(...dependencies);
-                Reflect.defineMetadata(providerToken, provider, this.module);
-            }
-            this.providers.set(providerToken, providerInstance);
-        }
-    }
-    ;
-    getInjectProviderWithInstance(injectProvider) {
-        if (!injectProvider?.token)
-            return null;
-        let injectInstance;
-        if (injectProvider?.useValue) {
-            injectInstance = injectProvider.useValue;
-        }
-        if (injectProvider?.useFactory) {
-            const factory = injectProvider.useFactory;
-            try {
-                if (TypeSpecifier.isClass(factory)) {
-                    injectInstance = new injectProvider.useFactory();
-                }
-                else {
-                    injectInstance = injectProvider.useFactory();
-                }
-            }
-            catch (error) {
-                console.error('A factory can be either a function or a class.', error);
-                return null;
-            }
-        }
-        return {
-            token: injectProvider.token,
-            instance: injectInstance,
-        };
-    }
-    ;
-    registerControllers() {
-        const controllers = this.module.controllers;
-        if (!controllers)
-            return;
-        for (const controller of controllers) {
-            if (this.controllers.has(controller))
-                continue;
-            const dependencyTokens = Reflect.getMetadata("design:paramtypes" /* E_TOKENS.DESIGN_PARAMTYPES */, controller);
-            const dependencies = [];
-            dependencyTokens?.forEach((dependencyToken) => {
-                if (!this.providers.has(dependencyToken))
-                    return console.warn(`[WARN] ${dependencyToken} is not provide in`, String(this));
-                dependencies.push(this.providers.get(dependencyToken));
-            });
-            const controllerToken = Reflect.getMetadata("controller:prefix" /* E_TOKENS.CONTROLLER_PREFIX */, controller) || controller;
-            const controllerInstance = new controller(...dependencies);
-            this.controllers.set(controllerToken, controllerInstance);
-        }
-    }
-    ;
-    getController(controllerToken) {
-        return this.controllers.get(controllerToken);
-    }
-    ;
-}
-
-function of(mapper) {
-    const entryList = Array.from(mapper.entries());
-    return entryList.map((entry) => {
-        return {
-            key: entry[0],
-            value: entry[1],
-        };
-    });
-}
-
-class Pool {
-    factory;
-    _pool = new Map();
-    constructor(factory) {
-        this.factory = factory;
-    }
-    ;
-    acquire() {
-        return of(this._pool)
-            .map(({ value }) => value)
-            .map(this.factory);
-    }
-    ;
-    release(data) {
-        this._pool.delete(data);
-    }
-    ;
-    append(data) {
-        this._pool.set(data, data);
-    }
-    ;
-}
-
-class AuditContainer {
-    providers = new Map();
-    providersPool = new Pool((data) => data);
-    addProviderToPool(type, providerToken) {
-        this.providersPool.append({
-            provider: providerToken,
-            type,
-        });
-    }
-    ;
-    registerInnerInject(injectProvider) {
-        this.registerGlobalInject(injectProvider);
-    }
-    processProvidersInPool() {
-        const providers = this.providersPool.acquire();
-        const providersByType = {
-            ["inject" /* E_PROVIDER_TYPES.INJECT */]: [],
-            ["injectable" /* E_PROVIDER_TYPES.INJECTABLE */]: [],
-        };
-        providers.forEach(({ type, provider }) => {
-            const condition = type === "injectable" /* E_PROVIDER_TYPES.INJECTABLE */ || type === "inject" /* E_PROVIDER_TYPES.INJECT */;
-            if (condition) {
-                providersByType[type].push(provider);
-            }
-        });
-        this.dispatchRegisterProviders(providersByType, "inject" /* E_PROVIDER_TYPES.INJECT */);
-        this.dispatchRegisterProviders(providersByType, "injectable" /* E_PROVIDER_TYPES.INJECTABLE */);
-    }
-    ;
-    dispatchRegisterProviders(providersByType, type) {
-        providersByType[type].forEach((provider) => {
-            switch (type) {
-                case "inject" /* E_PROVIDER_TYPES.INJECT */:
-                    this.registerGlobalInject(provider);
-                    break;
-                case "injectable" /* E_PROVIDER_TYPES.INJECTABLE */:
-                    this.registerGlobalInjectable(provider);
-                    break;
-            }
-            this.providersPool.release(provider);
-        });
-    }
-    ;
-    registerGlobalInjectable(providerToken) {
-        if (providerToken?.token) {
-            if (this.providers.has(providerToken.token))
-                return this.providers.get(providerToken.token);
-        }
-        else {
-            if (this.providers.has(providerToken))
-                return this.providers.get(providerToken);
-        }
-        const dependencies = [];
-        const dependenciesTokens = Reflect.getMetadata("design:paramtypes" /* E_TOKENS.DESIGN_PARAMTYPES */, providerToken);
-        const injectTokens = Reflect.getMetadata("inject:tokens" /* E_TOKENS.INJECT_TOKENS */, providerToken);
-        dependenciesTokens?.forEach((dependencyToken, index) => {
-            const injectToken = injectTokens?.find((injectTokenObject) => injectTokenObject.index === index);
-            let injectInstance = injectToken || dependencyToken;
-            const dependency = this.registerGlobalInjectable(injectInstance);
-            dependencies.push(dependency);
-        });
-        const provider = new providerToken(...dependencies);
-        this.providers.set(providerToken, provider);
-        return provider;
-    }
-    ;
-    registerGlobalInject(injectProvider) {
-        let injectInstance;
-        if (injectProvider?.useValue) {
-            injectInstance = injectProvider.useValue;
-        }
-        if (injectProvider?.useFactory) {
-            const factory = injectProvider.useFactory;
-            try {
-                if (TypeSpecifier.isClass(factory)) {
-                    injectInstance = new injectProvider.useFactory();
-                }
-                else {
-                    injectInstance = injectProvider.useFactory();
-                }
-            }
-            catch (error) {
-                console.error('A factory can be either a function or a class.', error);
-                return error;
-            }
-        }
-        this.providers.set(injectProvider.token, injectInstance);
-    }
-    ;
-}
-
-class Container extends AuditContainer {
-    _modules = new Map();
-    get modules() {
-        return this._modules;
-    }
-    ;
-    registerModule(module) {
-        if (this._modules.has(module))
-            return console.warn(`Module has in Container`);
-        this.processProvidersInPool();
-        const moduleInstance = new ModuleRef(this, module);
-        this._modules.set(module, moduleInstance);
-    }
-    ;
-    getModuleByName(moduleName) {
-        return of(this._modules).find(({ key }) => moduleName === key.name);
-    }
-    ;
-    getController(prefix) {
-        return of(this._modules).map(({ value }) => {
-            return value.getController(prefix);
-        }).find((controller) => !!controller);
-    }
-    ;
-    findModuleByProviderToken(providerToken) {
-        let module = null;
-        this._modules.forEach((moduleRef, moduleClass) => {
-            if (moduleClass.providers?.includes(providerToken)) {
-                module = {
-                    token: moduleClass,
-                    reference: moduleRef,
-                };
-            }
-        });
-        return module;
-    }
-    ;
-}
-const container = new Container();
-
-function Controller(prefix) {
-    return (target) => {
-        Reflect.defineMetadata("controller:prefix" /* E_TOKENS.CONTROLLER_PREFIX */, prefix, target);
-    };
-}
-
-function Module(options) {
-    return (target) => {
-        Reflect.defineProperty(target, 'name', {
-            value: options.name,
-            writable: false,
-            configurable: false,
-        });
-        Reflect.defineProperty(target, 'controllers', {
-            value: options.controllers,
-            writable: false,
-            configurable: false,
-        });
-        Reflect.defineProperty(target, 'providers', {
-            value: options.providers,
-            writable: false,
-            configurable: false,
-        });
-        registerProviders(options.providers);
-    };
-}
-function registerProviders(providers) {
-    providers?.forEach((provider) => {
-        const isObjectProvider = typeof provider === 'object' && !!provider?.token;
-        if (isObjectProvider) {
-            container.addProviderToPool("inject" /* E_PROVIDER_TYPES.INJECT */, provider);
-        }
-    });
-}
-
-function Injectable() {
-    return (target) => {
-        container.addProviderToPool("injectable" /* E_PROVIDER_TYPES.INJECTABLE */, target);
-    };
-}
-function Inject(token) {
-    return (target, _, parameterIndex) => {
-        const tokens = Reflect.getMetadata("inject:tokens" /* E_TOKENS.INJECT_TOKENS */, target) || [];
-        tokens.push({
-            index: parameterIndex,
-            token,
-        });
-        Reflect.defineMetadata("inject:tokens" /* E_TOKENS.INJECT_TOKENS */, tokens, target);
-    };
-}
-
-class AbstractModule {
-    static name;
-    static controllers = [];
-    static providers = [];
-}
-
-class Queue {
-    _storage = {};
-    _oldestIndex = 1;
-    _newestIndex = 1;
-    get count() {
-        return this._newestIndex - this._oldestIndex;
-    }
-    enqueue(data) {
-        this._storage[this._newestIndex] = data;
-        this._newestIndex++;
-    }
-    dequeue() {
-        const oldestIndex = this._oldestIndex;
-        const deletedData = this._storage[oldestIndex];
-        delete this._storage[oldestIndex];
-        this._oldestIndex++;
-        return deletedData;
-    }
-    toArray() {
-        return Object.values(this._storage);
-    }
-}
-
-var moduleManager = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AbstractModule: AbstractModule,
-    Container: Container,
-    Controller: Controller,
-    Inject: Inject,
-    Injectable: Injectable,
-    Module: Module,
-    ModuleRef: ModuleRef,
-    Queue: Queue,
-    TypeSpecifier: TypeSpecifier,
-    container: container,
-    of: of
-});
-
-exports.E_DRIVER_CLASSES = void 0;
-(function (E_DRIVER_CLASSES) {
-    E_DRIVER_CLASSES["shopify"] = "ShopifyDriver";
-    E_DRIVER_CLASSES["woo"] = "WooDriver";
-})(exports.E_DRIVER_CLASSES || (exports.E_DRIVER_CLASSES = {}));
-
-exports.E_DRIVER_TOKENS = void 0;
-(function (E_DRIVER_TOKENS) {
-    E_DRIVER_TOKENS["ENVIRONMENTS"] = "ENVIRONMENTS";
-})(exports.E_DRIVER_TOKENS || (exports.E_DRIVER_TOKENS = {}));
-
-exports.E_MANDATORY_CONTROLLERS = void 0;
-(function (E_MANDATORY_CONTROLLERS) {
-    E_MANDATORY_CONTROLLERS["LINE_ITEMS"] = "line-items";
-    E_MANDATORY_CONTROLLERS["PREVIEW"] = "preview";
-    E_MANDATORY_CONTROLLERS["PRICING"] = "pricing";
-    E_MANDATORY_CONTROLLERS["RETURN_TO_EDIT"] = "return-to-edit";
-})(exports.E_MANDATORY_CONTROLLERS || (exports.E_MANDATORY_CONTROLLERS = {}));
-
-class AbstractLineItemsController {
-}
-class AbstractPricingController {
-}
-class AbstractPreviewController {
-}
-class AbstractCheckoutController {
-}
-class AbstractReturnToEditController {
-}
-
-/*
-from https://github.com/substack/vm-browserify/blob/bfd7c5f59edec856dc7efe0b77a4f6b2fa20f226/index.js
-
-MIT license no Copyright holder mentioned
-*/
-
-
-function Object_keys(obj) {
-  if (Object.keys) return Object.keys(obj)
-  else {
-    var res = [];
-    for (var key in obj) res.push(key);
-    return res;
-  }
-}
-
-function forEach(xs, fn) {
-  if (xs.forEach) return xs.forEach(fn)
-  else
-    for (var i = 0; i < xs.length; i++) {
-      fn(xs[i], i, xs);
-    }
-}
-var _defineProp;
-
-function defineProp(obj, name, value) {
-  if (typeof _defineProp !== 'function') {
-    _defineProp = createDefineProp;
-  }
-  _defineProp(obj, name, value);
-}
-
-function createDefineProp() {
-  try {
-    Object.defineProperty({}, '_', {});
-    return function(obj, name, value) {
-      Object.defineProperty(obj, name, {
-        writable: true,
-        enumerable: false,
-        configurable: true,
-        value: value
-      });
-    };
-  } catch (e) {
-    return function(obj, name, value) {
-      obj[name] = value;
-    };
-  }
-}
-
-var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function',
-  'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError',
-  'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError',
-  'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape',
-  'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'
-];
-
-function Context() {}
-Context.prototype = {};
-
-function Script(code) {
-  if (!(this instanceof Script)) return new Script(code);
-  this.code = code;
-}
-function otherRunInContext(code, context) {
-  var args = Object_keys(global);
-  args.push('with (this.__ctx__){return eval(this.__code__)}');
-  var fn = Function.apply(null, args);
-  return fn.apply({
-    __code__: code,
-    __ctx__: context
-  });
-}
-Script.prototype.runInContext = function(context) {
-  if (!(context instanceof Context)) {
-    throw new TypeError('needs a \'context\' argument.');
-  }
-  if (global.document) {
-    var iframe = global.document.createElement('iframe');
-    if (!iframe.style) iframe.style = {};
-    iframe.style.display = 'none';
-
-    global.document.body.appendChild(iframe);
-
-    var win = iframe.contentWindow;
-    var wEval = win.eval,
-      wExecScript = win.execScript;
-
-    if (!wEval && wExecScript) {
-      // win.eval() magically appears when this is called in IE:
-      wExecScript.call(win, 'null');
-      wEval = win.eval;
-    }
-
-    forEach(Object_keys(context), function(key) {
-      win[key] = context[key];
-    });
-    forEach(globals, function(key) {
-      if (context[key]) {
-        win[key] = context[key];
-      }
-    });
-
-    var winKeys = Object_keys(win);
-
-    var res = wEval.call(win, this.code);
-
-    forEach(Object_keys(win), function(key) {
-      // Avoid copying circular objects like `top` and `window` by only
-      // updating existing context properties or new properties in the `win`
-      // that was only introduced after the eval.
-      if (key in context || indexOf(winKeys, key) === -1) {
-        context[key] = win[key];
-      }
-    });
-
-    forEach(globals, function(key) {
-      if (!(key in context)) {
-        defineProp(context, key, win[key]);
-      }
-    });
-    global.document.body.removeChild(iframe);
-
-    return res;
-  }
-  return otherRunInContext(this.code, context);
-};
-
-Script.prototype.runInThisContext = function() {
-  var fn = new Function('code', 'return eval(code);');
-  return fn.call(global, this.code); // maybe...
-};
-
-Script.prototype.runInNewContext = function(context) {
-  var ctx = createContext(context);
-  var res = this.runInContext(ctx);
-  if (context) {
-    forEach(Object_keys(ctx), function(key) {
-      context[key] = ctx[key];
-    });
-  }
-
-  return res;
-};
-
-function createContext(context) {
-  if (isContext(context)) {
-    return context;
-  }
-  var copy = new Context();
-  if (typeof context === 'object') {
-    forEach(Object_keys(context), function(key) {
-      copy[key] = context[key];
-    });
-  }
-  return copy;
-}
-function runInContext(code, contextifiedSandbox, options) {
-  var script = new Script(code);
-  return script.runInContext(contextifiedSandbox, options);
-}
-function isContext(context) {
-  return context instanceof Context;
-}
-
-
-/*
-from indexOf
-@ author tjholowaychuk
-@ license MIT
-*/
-var _indexOf = [].indexOf;
-
-function indexOf(arr, obj){
-  if (_indexOf) return arr.indexOf(obj);
-  for (var i = 0; i < arr.length; ++i) {
-    if (arr[i] === obj) return i;
-  }
-  return -1;
-}
-
-async function virtualMachine(code) {
-    const context = {
-        module: { exports: {} },
-        exports: {},
-        require: (id) => {
-            if (id === '@savafeed/module-manager') {
-                return moduleManager;
-            }
-            throw new Error(`Cannot require('${id}') in this context`);
-        },
-        console,
-        setTimeout,
-        setInterval,
-        Reflect,
-        Promise,
-        URL,
-        fetch,
-    };
-    const isNodeJsEnv = typeof document === 'undefined';
-    if (isNodeJsEnv) {
-        await import('reflect-metadata');
-    }
-    else {
-        // @ts-ignore
-        await import('https://unpkg.com/reflect-metadata@0.2.2/Reflect.js');
-    }
-    context.Reflect = Reflect;
-    const sandbox = createContext(context);
-    runInContext(code, sandbox);
-    const moduleObject = sandbox.exports;
-    return moduleObject;
-}
-
-class DriverProcessor {
-    // static CDN: string = 'http://localhost:5000';
-    static CDN = 'https://unpkg.com/@savafeed';
-    static async getDriverModule(bootstrapOptions) {
-        let driverModule;
-        if (bootstrapOptions?.default) {
-            driverModule = await DriverProcessor.defaultBootstrapDriver(bootstrapOptions.default);
-        }
-        else if (bootstrapOptions?.custom) {
-            driverModule = await DriverProcessor.customBootstrapDriver(bootstrapOptions.custom);
-        }
-        else {
-            throw new Error('Driver not found');
-        }
-        return driverModule;
-    }
-    ;
-    static async defaultBootstrapDriver(options) {
-        if (!options?.name)
-            throw new Error(`Unable to get driver by this name: ${options?.name}`);
-        const driver = await DriverProcessor.pullDriverByName(options.name, options.scriptType);
-        const driverModule = DriverProcessor.exportDriverModule(driver, {
-            scriptType: options.scriptType,
-            name: options.name,
-        });
-        return driverModule;
-    }
-    static async customBootstrapDriver(options) {
-        if (!options?.link)
-            throw new Error('Driver link not found');
-        if (!options?.className)
-            throw new Error('Driver class name not found');
-        const driver = await DriverProcessor.pullDriverByLink(options.link);
-        const driverModule = DriverProcessor.exportDriverModule(driver, {
-            scriptType: options.scriptType,
-            name: options.className,
-        });
-        return driverModule;
-    }
-    static exportDriverModule(driver, options) {
-        if (!driver)
-            throw new Error('Driver not found');
-        const currentScriptType = (!!options.scriptType) ? options.scriptType : 'umd';
-        const driverClassName = options.name;
-        switch (currentScriptType) {
-            case 'esm':
-                return driver?.default[exports.E_DRIVER_CLASSES[driverClassName]] || driver[exports.E_DRIVER_CLASSES[driverClassName]];
-            case 'umd':
-                return driver?.default[exports.E_DRIVER_CLASSES[driverClassName]] || driver[exports.E_DRIVER_CLASSES[driverClassName]];
-            case 'cjs':
-                return driver[exports.E_DRIVER_CLASSES[driverClassName]];
-            default:
-                throw new Error(`Unknown script type: ${currentScriptType}`);
-        }
-    }
-    static async pullDriverByLink(link) {
-        if (!link)
-            throw new Error('Driver link not found');
-        const response = await fetch(link);
-        if (!response?.ok) {
-            throw new Error(`Failed to load script from CDN: ${response.statusText}`);
-        }
-        const scriptContent = await response.text();
-        const driver = await virtualMachine(scriptContent);
-        return driver;
-    }
-    ;
-    static async pullDriverByName(driverName, scriptType) {
-        if (!driverName)
-            throw new Error('Driver name not found');
-        const currentScriptType = (!!scriptType) ? scriptType : 'umd';
-        const link = `${DriverProcessor.CDN}/${driverName}-driver@latest/${driverName}.driver.${currentScriptType}.js`;
-        const response = await fetch(link);
-        if (!response?.ok) {
-            throw new Error(`Failed to load script from CDN: ${response.statusText}`);
-        }
-        const scriptContent = await response.text();
-        const driver = await virtualMachine(scriptContent);
-        return driver;
-    }
-    ;
-}
-
-class DriverManager {
-    appContainer;
-    environments;
-    constructor(appContainer, environments) {
-        this.appContainer = appContainer;
-        this.environments = environments;
-        if (!!this?.environments?.core) {
-            this.setCoreOptions(this.environments.core);
-        }
-    }
-    ;
-    async setup() {
-        if (this.appContainer.providers.has(exports.E_DRIVER_TOKENS.ENVIRONMENTS)) {
-            throw new Error(`Provider with token "${exports.E_DRIVER_TOKENS.ENVIRONMENTS}" already exists`);
-        }
-        this.appContainer.providers.set(exports.E_DRIVER_TOKENS.ENVIRONMENTS, this.environments);
-        if (this.environments?.input?.eCommerce) {
-            return await this.bootstrapDriver({
-                default: {
-                    name: this.environments?.input?.eCommerce,
-                    scriptType: this.environments?.input?.driverScriptType,
-                },
-            });
-        }
-        else {
-            return await this.bootstrapDriver({
-                custom: {
-                    link: this.environments?.input?.driverLink,
-                    className: this.environments?.input?.driverClassName,
-                },
-            });
-        }
-    }
-    setCoreOptions(options) {
-        if (options?.cdn) {
-            DriverProcessor.CDN = options.cdn;
-        }
-    }
-    getController(controllerName) {
-        return this.appContainer.getController(controllerName);
-    }
-    async bootstrapDriver(bootstrapOptions) {
-        const driverModule = await DriverProcessor.getDriverModule(bootstrapOptions);
-        if (!driverModule) {
-            console.error('Driver not found!', driverModule);
-            console.warn('Bootstrap options:', bootstrapOptions);
-            let stringOptions;
-            try {
-                stringOptions = JSON.stringify(bootstrapOptions);
-            }
-            catch (ex) {
-                console.warn('Error trying to convert bootstrap parameters to JSON to show in error:', ex);
-                stringOptions = String(bootstrapOptions);
-            }
-            throw new Error(`Driver with options: (${stringOptions}) not found`);
-        }
-        this.appContainer.registerModule(driverModule);
-        return driverModule;
-    }
-    ;
-}
+var moduleManager = require('@savafeed/module-manager');
+var driverManager = require('@savafeed/driver-manager');
 
 class DomPolyfill {
     static get document() {
@@ -817,12 +38,12 @@ class DomPolyfill {
 
 class CartSDK {
     environments;
-    appContainer = container;
+    appContainer = moduleManager.container;
     driverManager;
     controllers = new Map();
     constructor(environments) {
         this.environments = environments;
-        this.driverManager = new DriverManager(this.appContainer, this.environments);
+        this.driverManager = new driverManager.DriverManager(this.appContainer, this.environments);
     }
     ;
     async bootstrap() {
@@ -837,10 +58,10 @@ class CartSDK {
     }
     purchasingMandatoryControllers() {
         const mandatoryControllers = [
-            exports.E_MANDATORY_CONTROLLERS.LINE_ITEMS,
-            exports.E_MANDATORY_CONTROLLERS.PREVIEW,
-            exports.E_MANDATORY_CONTROLLERS.PRICING,
-            exports.E_MANDATORY_CONTROLLERS.RETURN_TO_EDIT,
+            driverManager.E_MANDATORY_CONTROLLERS.LINE_ITEMS,
+            driverManager.E_MANDATORY_CONTROLLERS.PREVIEW,
+            driverManager.E_MANDATORY_CONTROLLERS.PRICING,
+            driverManager.E_MANDATORY_CONTROLLERS.RETURN_TO_EDIT,
         ];
         mandatoryControllers.forEach((controllerName) => {
             const controllerInstance = this.driverManager.getController(controllerName);
@@ -857,11 +78,41 @@ if ($window) {
     $window.CartSDK = CartSDK;
 }
 
-exports.AbstractCheckoutController = AbstractCheckoutController;
-exports.AbstractLineItemsController = AbstractLineItemsController;
-exports.AbstractPreviewController = AbstractPreviewController;
-exports.AbstractPricingController = AbstractPricingController;
-exports.AbstractReturnToEditController = AbstractReturnToEditController;
+Object.defineProperty(exports, "AbstractCheckoutController", {
+    enumerable: true,
+    get: function () { return driverManager.AbstractCheckoutController; }
+});
+Object.defineProperty(exports, "AbstractLineItemsController", {
+    enumerable: true,
+    get: function () { return driverManager.AbstractLineItemsController; }
+});
+Object.defineProperty(exports, "AbstractPreviewController", {
+    enumerable: true,
+    get: function () { return driverManager.AbstractPreviewController; }
+});
+Object.defineProperty(exports, "AbstractPricingController", {
+    enumerable: true,
+    get: function () { return driverManager.AbstractPricingController; }
+});
+Object.defineProperty(exports, "AbstractReturnToEditController", {
+    enumerable: true,
+    get: function () { return driverManager.AbstractReturnToEditController; }
+});
+Object.defineProperty(exports, "DriverManager", {
+    enumerable: true,
+    get: function () { return driverManager.DriverManager; }
+});
+Object.defineProperty(exports, "E_DRIVER_CLASSES", {
+    enumerable: true,
+    get: function () { return driverManager.E_DRIVER_CLASSES; }
+});
+Object.defineProperty(exports, "E_DRIVER_TOKENS", {
+    enumerable: true,
+    get: function () { return driverManager.E_DRIVER_TOKENS; }
+});
+Object.defineProperty(exports, "E_MANDATORY_CONTROLLERS", {
+    enumerable: true,
+    get: function () { return driverManager.E_MANDATORY_CONTROLLERS; }
+});
 exports.CartSDK = CartSDK;
-exports.DriverManager = DriverManager;
 //# sourceMappingURL=cart-api-sdk.cjs.js.map