@limetech/lime-web-components 4.48.2 → 4.49.1-alpha.4

package/dist/es5/core/decorators/factory.spec.js

@@ -0,0 +1,495 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var getElement;
+jest.mock('@stencil/core', function () {
+    var original = jest.requireActual('@stencil/core');
+    return tslib_1.__assign(tslib_1.__assign({}, original), { getElement: function () { return getElement(); } });
+});
+var factory_1 = require("./factory");
+var rxjs_1 = require("rxjs");
+var operators_1 = require("rxjs/operators");
+describe('createStateDecorator', function () {
+    var platform;
+    var context;
+    var service;
+    beforeEach(function () {
+        service = new TestService();
+        var services = {
+            test: service,
+        };
+        platform = {
+            has: jest.fn(function (name) { return name in services; }),
+            get: jest.fn(function (name) { return services[name]; }),
+        };
+        context = {};
+    });
+    describe('when using a state decorator on a property', function () {
+        it('adds required lifecycle hooks on the component', function () {
+            var Decorator = function () { return (0, factory_1.createStateDecorator)({}, { name: 'test' }); };
+            var MyComponent = (function () {
+                function MyComponent() {
+                }
+                tslib_1.__decorate([
+                    Decorator()
+                ], MyComponent.prototype, "foo", void 0);
+                return MyComponent;
+            }());
+            var component = new MyComponent();
+            expect(typeof component.connectedCallback).toEqual('function');
+            expect(typeof component.componentWillLoad).toEqual('function');
+            expect(typeof component.componentWillUpdate).toEqual('function');
+            expect(typeof component.componentDidUnload).toEqual('function');
+            expect(typeof component.disconnectedCallback).toEqual('function');
+        });
+    });
+    describe('when more than one property is decorated', function () {
+        it('only extends the lifecycle methods once', function () {
+            var Decorator = function () { return (0, factory_1.createStateDecorator)({}, { name: 'test' }); };
+            var MyComponent = (function () {
+                function MyComponent() {
+                }
+                tslib_1.__decorate([
+                    Decorator()
+                ], MyComponent.prototype, "foo", void 0);
+                return MyComponent;
+            }());
+            var component = new MyComponent();
+            var connectedCallback = component.connectedCallback;
+            var componentWillLoad = component.componentWillLoad;
+            var componentWillUpdate = component.componentWillUpdate;
+            var componentDidUnload = component.componentDidUnload;
+            var disconnectedCallback = component.disconnectedCallback;
+            Decorator()(MyComponent.prototype, 'bar');
+            expect(component.connectedCallback).toEqual(connectedCallback);
+            expect(component.componentWillLoad).toEqual(componentWillLoad);
+            expect(component.componentWillUpdate).toEqual(componentWillUpdate);
+            expect(component.componentDidUnload).toEqual(componentDidUnload);
+            expect(component.disconnectedCallback).toEqual(disconnectedCallback);
+        });
+    });
+    describe('when lifecycle hooks already exist', function () {
+        it('overwrites the lifecycle hooks', function () {
+            var Decorator = function () { return (0, factory_1.createStateDecorator)({}, { name: 'test' }); };
+            var MyComponent = (function () {
+                function MyComponent() {
+                }
+                MyComponent.prototype.connectedCallback = function () { };
+                MyComponent.prototype.componentWillLoad = function () { };
+                MyComponent.prototype.componentWillUpdate = function () { };
+                MyComponent.prototype.componentDidUnload = function () { };
+                MyComponent.prototype.disconnectedCallback = function () { };
+                return MyComponent;
+            }());
+            var component = new MyComponent();
+            var connectedCallback = component.connectedCallback;
+            var componentWillLoad = component.componentWillLoad;
+            var componentWillUpdate = component.componentWillUpdate;
+            var componentDidUnload = component.componentDidUnload;
+            var disconnectedCallback = component.disconnectedCallback;
+            Decorator()(MyComponent.prototype, 'foo');
+            expect(component.connectedCallback).not.toEqual(connectedCallback);
+            expect(component.componentWillLoad).not.toEqual(componentWillLoad);
+            expect(component.componentWillUpdate).not.toEqual(componentWillUpdate);
+            expect(component.componentDidUnload).not.toEqual(componentDidUnload);
+            expect(component.disconnectedCallback).not.toEqual(disconnectedCallback);
+        });
+    });
+    describe('when invoking connectedCallback without required properties', function () {
+        var component;
+        var element;
+        beforeEach(function () {
+            var Decorator = function () { return (0, factory_1.createStateDecorator)({}, { name: 'test' }); };
+            var MyComponent = (function () {
+                function MyComponent() {
+                }
+                tslib_1.__decorate([
+                    Decorator()
+                ], MyComponent.prototype, "foo", void 0);
+                return MyComponent;
+            }());
+            component = new MyComponent();
+            element = { platform: null, context: null };
+            getElement = function () { return element; };
+        });
+        it('returns a promise that does not resolve', function () {
+            expect.assertions(0);
+            component.connectedCallback().then(function () {
+                expect(false).toBeTruthy();
+            });
+        });
+        it('returns a promise that resolves when platform and context has been set', function () {
+            expect.assertions(1);
+            component.connectedCallback().then(function () {
+                expect(true).toBeTruthy();
+            });
+            component.platform = platform;
+            component.context = context;
+            element.platform = platform;
+            element.context = context;
+        });
+    });
+    describe('when invoking componentWillLoad without required properties', function () {
+        var component;
+        var element;
+        var spy;
+        beforeEach(function () {
+            spy = jest.fn(function () { });
+            var Decorator = function () { return (0, factory_1.createStateDecorator)({}, { name: 'test' }); };
+            var MyComponent = (function () {
+                function MyComponent() {
+                }
+                MyComponent.prototype.componentWillLoad = function () {
+                    spy();
+                };
+                tslib_1.__decorate([
+                    Decorator()
+                ], MyComponent.prototype, "foo", void 0);
+                return MyComponent;
+            }());
+            component = new MyComponent();
+            element = { platform: null, context: null };
+            getElement = function () { return element; };
+        });
+        it('returns a promise that does not resolve', function () {
+            expect.assertions(0);
+            component.connectedCallback();
+            component.componentWillLoad().then(function () {
+                expect(false).toBeTruthy();
+                expect(spy).not.toHaveBeenCalled();
+            });
+        });
+        it('returns a promise that resolves when platform and context has been set', function () {
+            expect.assertions(3);
+            component.connectedCallback();
+            component.componentWillLoad().then(function () {
+                expect(true).toBeTruthy();
+                expect(spy).toHaveBeenCalledTimes(1);
+            });
+            expect(spy).toHaveBeenCalledTimes(0);
+            component.platform = platform;
+            component.context = context;
+            element.platform = platform;
+            element.context = context;
+        });
+    });
+    describe('when invoking connectedCallback or componentWillLoad with required properties', function () {
+        var component;
+        beforeEach(function () {
+            component = createComponent();
+        });
+        it('creates a subscription on the service', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        expect(service.getSubscriptions().length).toEqual(1);
+                        return [2];
+                }
+            });
+        }); });
+        it('creates a subscription on the service', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, component.componentWillLoad()];
+                    case 1:
+                        _a.sent();
+                        expect(service.getSubscriptions().length).toEqual(1);
+                        return [2];
+                }
+            });
+        }); });
+        describe('when invoking both connectedCallback and componentWillLoad', function () {
+            it('creates only one subscription on the service', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, component.connectedCallback()];
+                        case 1:
+                            _a.sent();
+                            return [4, component.componentWillLoad()];
+                        case 2:
+                            _a.sent();
+                            expect(service.getSubscriptions().length).toEqual(1);
+                            return [2];
+                    }
+                });
+            }); });
+        });
+    });
+    describe('when multiple properties are decorated', function () {
+        var component;
+        beforeEach(function () {
+            component = createComponent({ foo: true, bar: true });
+        });
+        it('connectedCallback creates a subscription for each property', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        expect(service.getSubscriptions().length).toEqual(2);
+                        return [2];
+                }
+            });
+        }); });
+    });
+    describe('when invoking disconnectedCallback', function () {
+        var component;
+        beforeEach(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        component = createComponent({ foo: true, bar: true });
+                        return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        }); });
+        it('removes the subscriptions', function () {
+            expect(service.getSubscriptions().length).toEqual(2);
+            component.disconnectedCallback();
+            expect(service.getSubscriptions().length).toEqual(0);
+        });
+        describe('when invoked multiple times', function () {
+            it('does not crash', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    expect(service.getSubscriptions().length).toEqual(2);
+                    component.disconnectedCallback();
+                    expect(service.getSubscriptions().length).toEqual(0);
+                    expect(function () { return component.disconnectedCallback(); }).not.toThrow();
+                    return [2];
+                });
+            }); });
+        });
+        describe('when a component is inserted in the DOM again after being removed', function () {
+            it('creates a subscription on the service again', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            expect(service.getSubscriptions().length).toEqual(2);
+                            component.disconnectedCallback();
+                            expect(service.getSubscriptions().length).toEqual(0);
+                            return [4, component.connectedCallback()];
+                        case 1:
+                            _a.sent();
+                            expect(service.getSubscriptions().length).toEqual(2);
+                            return [2];
+                    }
+                });
+            }); });
+        });
+    });
+    describe('when context is set on options', function () {
+        var component;
+        var options;
+        beforeEach(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = { context: null };
+                        component = createComponent({ foo: true, bar: true }, options);
+                        return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        }); });
+        it('sets the context option to an observable', function () {
+            expect(options.context).toBeInstanceOf(rxjs_1.Subject);
+        });
+        describe('when componentWillUpdate is invoked without a context change', function () {
+            it('does not emit a value on the observable', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                var spy;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            spy = jest.spyOn(options.context, 'next');
+                            return [4, component.componentWillUpdate()];
+                        case 1:
+                            _a.sent();
+                            expect(spy).not.toHaveBeenCalled();
+                            return [2];
+                    }
+                });
+            }); });
+        });
+        describe('when componentWillUpdate is invoked with a context change', function () {
+            it('emits a value on the observable', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                var spy, subject, value;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            spy = jest.spyOn(options.context, 'next');
+                            component.context = 'new context';
+                            return [4, component.componentWillUpdate()];
+                        case 1:
+                            _a.sent();
+                            expect(spy).toHaveBeenCalled();
+                            subject = options.context;
+                            return [4, subject.pipe((0, operators_1.take)(1)).toPromise()];
+                        case 2:
+                            value = _a.sent();
+                            expect(value).toEqual('new context');
+                            return [2];
+                    }
+                });
+            }); });
+        });
+    });
+    describe('when component has lifecycle methods', function () {
+        var component;
+        var options;
+        var methods;
+        beforeEach(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                options = { context: null };
+                methods = {
+                    connectedCallback: jest.fn(),
+                    componentWillLoad: jest.fn(),
+                    componentWillUpdate: jest.fn(),
+                    componentDidUnload: jest.fn(),
+                    disconnectedCallback: jest.fn(),
+                };
+                component = createComponent({ foo: true, bar: true }, options, methods);
+                return [2];
+            });
+        }); });
+        it('connectedCallback invokes the original connectedCallback', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expect(methods.connectedCallback).toHaveBeenCalledTimes(0);
+                        expect(component.connectedCallback).not.toEqual(methods.connectedCallback);
+                        return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        expect(methods.connectedCallback).toHaveBeenCalledTimes(1);
+                        return [2];
+                }
+            });
+        }); });
+        it('componentWillLoad invokes the original componentWillLoad', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expect(methods.componentWillLoad).toHaveBeenCalledTimes(0);
+                        expect(component.componentWillLoad).not.toEqual(methods.componentWillLoad);
+                        return [4, component.componentWillLoad()];
+                    case 1:
+                        _a.sent();
+                        expect(methods.componentWillLoad).toHaveBeenCalledTimes(1);
+                        return [2];
+                }
+            });
+        }); });
+        describe('when connectedCallback is invoked first', function () {
+            it('componentWillLoad invkoes the original componentWillLoad', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            expect(methods.componentWillLoad).toHaveBeenCalledTimes(0);
+                            expect(component.componentWillLoad).not.toEqual(methods.componentWillLoad);
+                            return [4, component.connectedCallback()];
+                        case 1:
+                            _a.sent();
+                            return [4, component.componentWillLoad()];
+                        case 2:
+                            _a.sent();
+                            expect(methods.componentWillLoad).toHaveBeenCalledTimes(1);
+                            return [2];
+                    }
+                });
+            }); });
+        });
+        it('componentWillUpdate invokes the original componentWillUpdate', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expect(methods.componentWillUpdate).toHaveBeenCalledTimes(0);
+                        expect(component.componentWillUpdate).not.toEqual(methods.componentWillUpdate);
+                        return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        component.componentWillUpdate();
+                        expect(methods.componentWillUpdate).toHaveBeenCalledTimes(1);
+                        return [2];
+                }
+            });
+        }); });
+        it('componentDidUnload invokes the original componentDidUnload', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expect(methods.componentDidUnload).toHaveBeenCalledTimes(0);
+                        expect(component.componentDidUnload).not.toEqual(methods.componentDidUnload);
+                        return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        component.componentDidUnload();
+                        expect(methods.componentDidUnload).toHaveBeenCalledTimes(1);
+                        return [2];
+                }
+            });
+        }); });
+        it('disconnectedCallback invokes the original disconnectedCallback', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expect(methods.disconnectedCallback).toHaveBeenCalledTimes(0);
+                        expect(component.disconnectedCallback).not.toEqual(methods.disconnectedCallback);
+                        return [4, component.connectedCallback()];
+                    case 1:
+                        _a.sent();
+                        component.disconnectedCallback();
+                        expect(methods.disconnectedCallback).toHaveBeenCalledTimes(1);
+                        return [2];
+                }
+            });
+        }); });
+    });
+    function createComponent(props, options, methods) {
+        if (props === void 0) { props = { foo: 'bar' }; }
+        if (options === void 0) { options = {}; }
+        if (methods === void 0) { methods = {}; }
+        var Decorator = function (o) { return (0, factory_1.createStateDecorator)(o, { name: 'test' }); };
+        var MyComponent = (function () {
+            function MyComponent() {
+            }
+            return MyComponent;
+        }());
+        Object.keys(methods).forEach(function (method) {
+            MyComponent.prototype[method] = methods[method];
+        });
+        var component = new MyComponent();
+        component.platform = platform;
+        component.context = context;
+        Object.keys(props).forEach(function (key) {
+            Decorator(options)(MyComponent.prototype, key);
+        });
+        return component;
+    }
+});
+var TestService = (function () {
+    function TestService() {
+        this.subscriptions = [];
+    }
+    TestService.prototype.subscribe = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.subscriptions.push(args);
+        return function () {
+            _this.subscriptions = _this.subscriptions.filter(function (item) { return item !== args; });
+        };
+    };
+    TestService.prototype.getSubscriptions = function () {
+        return this.subscriptions;
+    };
+    return TestService;
+}());

package/dist/es5/core/decorators/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/core/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./context"), exports);
+tslib_1.__exportStar(require("./platform"), exports);
+tslib_1.__exportStar(require("./lime-web-component"), exports);
+tslib_1.__exportStar(require("./plugin-loader"), exports);
+tslib_1.__exportStar(require("./state"), exports);
+tslib_1.__exportStar(require("./decorators"), exports);

package/dist/es5/core/lime-web-component.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/core/platform.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformServiceName = void 0;
+exports.PlatformServiceName = {
+    Route: 'route',
+};

package/dist/es5/core/plugin-loader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/core/state.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/device/decorator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectDevice = void 0;
+var core_1 = require("../core");
+var factory_1 = require("../core/decorators/factory");
+function SelectDevice(options) {
+    if (options === void 0) { options = {}; }
+    var config = {
+        name: core_1.PlatformServiceName.Device,
+    };
+    return (0, factory_1.createStateDecorator)(options, config);
+}
+exports.SelectDevice = SelectDevice;

package/dist/es5/device/device.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/device/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./device"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./decorator"), exports);

package/dist/es5/device/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var platform_1 = require("../core/platform");
+var SERVICE_NAME = 'state.device';
+platform_1.PlatformServiceName.Device = SERVICE_NAME;

package/dist/es5/dialog/dialog.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/dialog/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./dialog"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/dist/es5/dialog/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var platform_1 = require("../core/platform");
+var SERVICE_NAME = 'dialog';
+platform_1.PlatformServiceName.Dialog = SERVICE_NAME;

package/dist/es5/eventdispatcher/eventdispatcher.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/eventdispatcher/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./eventdispatcher"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/dist/es5/eventdispatcher/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var platform_1 = require("../core/platform");
+var SERVICE_NAME = 'eventDispatcher';
+platform_1.PlatformServiceName.EventDispatcher = SERVICE_NAME;

package/dist/es5/filter/decorator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectFilters = void 0;
+var core_1 = require("../core");
+var factory_1 = require("../core/decorators/factory");
+function SelectFilters(options) {
+    if (options === void 0) { options = {}; }
+    var config = {
+        name: core_1.PlatformServiceName.FilterRepository,
+    };
+    return (0, factory_1.createStateDecorator)(options, config);
+}
+exports.SelectFilters = SelectFilters;

package/dist/es5/filter/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./repository"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./decorator"), exports);

package/dist/es5/filter/repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/filter/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var platform_1 = require("../core/platform");
+var SERVICE_NAME = 'state.filters';
+platform_1.PlatformServiceName.FilterRepository = SERVICE_NAME;

package/dist/es5/http/http.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es5/http/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./http"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/dist/es5/http/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var platform_1 = require("../core/platform");
+var SERVICE_NAME = 'http';
+platform_1.PlatformServiceName.Http = SERVICE_NAME;