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

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

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStateDecorator = void 0;
+var tslib_1 = require("tslib");
+var core_1 = require("@stencil/core");
+var rxjs_1 = require("rxjs");
+function defaultOptionFactory(options) {
+    return options;
+}
+function createStateDecorator(options, config) {
+    return function (target, property) {
+        var properties = getComponentProperties(target, property, options, config);
+        if (properties.length === 1) {
+            extendLifecycleMethods(target, properties);
+        }
+    };
+}
+exports.createStateDecorator = createStateDecorator;
+var componentProperties = new WeakMap();
+var contexts = new WeakMap();
+var contextObservables = new WeakMap();
+var componentSubscriptions = new WeakMap();
+var connectedComponents = new WeakMap();
+function getComponentProperties(component, property, options, config) {
+    var properties = componentProperties.get(component);
+    if (!properties) {
+        properties = [];
+        componentProperties.set(component, properties);
+    }
+    properties.push({
+        options: options,
+        name: property,
+        optionFactory: config.optionFactory || defaultOptionFactory,
+        service: {
+            name: config.name,
+            method: config.method || 'subscribe',
+        },
+    });
+    return properties;
+}
+function extendLifecycleMethods(component, properties) {
+    component.connectedCallback = createConnectedCallback(component.connectedCallback, properties);
+    component.componentWillLoad = createComponentWillLoad(component.componentWillLoad, properties);
+    component.componentWillUpdate = createComponentWillUpdate(component.componentWillUpdate);
+    component.componentDidUnload = createDisconnectedCallback(component.componentDidUnload);
+    component.disconnectedCallback = createDisconnectedCallback(component.disconnectedCallback);
+}
+function createConnectedCallback(original, properties) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var observable;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        connectedComponents.set(this, true);
+                        componentSubscriptions.set(this, []);
+                        return [4, ensureLimeProps(this)];
+                    case 1:
+                        _a.sent();
+                        observable = new rxjs_1.BehaviorSubject(this.context);
+                        contexts.set(this, this.context);
+                        contextObservables.set(this, observable);
+                        properties.forEach(function (property) {
+                            property.options = property.optionFactory(property.options, _this);
+                            if (isContextAware(property.options)) {
+                                property.options.context = observable;
+                            }
+                            subscribe(_this, property);
+                        });
+                        if (original) {
+                            return [2, original.apply(this, args)];
+                        }
+                        return [2];
+                }
+            });
+        });
+    };
+}
+function createComponentWillLoad(original, properties) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var connectedCallback;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(connectedComponents.get(this) === true)) return [3, 2];
+                        return [4, ensureLimeProps(this)];
+                    case 1:
+                        _a.sent();
+                        if (original) {
+                            return [2, original.apply(this, args)];
+                        }
+                        return [2];
+                    case 2:
+                        connectedCallback = createConnectedCallback(original, properties);
+                        return [2, connectedCallback.apply(this, args)];
+                }
+            });
+        });
+    };
+}
+function createComponentWillUpdate(original) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var context, observable;
+            return tslib_1.__generator(this, function (_a) {
+                context = contexts.get(this);
+                if (context !== this.context) {
+                    contexts.set(this, this.context);
+                    observable = contextObservables.get(this);
+                    observable.next(this.context);
+                }
+                if (original) {
+                    return [2, original.apply(this, args)];
+                }
+                return [2];
+            });
+        });
+    };
+}
+function createDisconnectedCallback(original) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result;
+            return tslib_1.__generator(this, function (_a) {
+                if (original) {
+                    result = original.apply(this, args);
+                }
+                unsubscribeAll(this);
+                return [2, result];
+            });
+        });
+    };
+}
+function isContextAware(options) {
+    return 'context' in options;
+}
+function ensureLimeProps(target) {
+    var promises = [];
+    if (!target.platform) {
+        promises.push(waitForProp(target, 'platform'));
+    }
+    if (!target.context) {
+        promises.push(waitForProp(target, 'context'));
+    }
+    if (!promises.length) {
+        return Promise.resolve();
+    }
+    return Promise.all(promises);
+}
+function waitForProp(target, property) {
+    var element = (0, core_1.getElement)(target);
+    return new Promise(function (resolve) {
+        Object.defineProperty(element, property, {
+            set: function (value) {
+                delete element[property];
+                element[property] = value;
+                resolve();
+            },
+        });
+    });
+}
+function subscribe(component, property) {
+    var subscription = createSubscription(component, property);
+    var subscriptions = componentSubscriptions.get(component);
+    subscriptions.push(subscription);
+}
+function unsubscribeAll(component) {
+    var subscriptions = componentSubscriptions.get(component);
+    subscriptions.forEach(function (unsubscribe) { return unsubscribe(); });
+    componentSubscriptions.set(component, []);
+}
+function mapState(instance, property) {
+    return function (state) {
+        instance[property] = state;
+    };
+}
+function createSubscription(component, property) {
+    var myOptions = tslib_1.__assign({}, property.options);
+    bindFunctions(myOptions, component);
+    var name = property.service.name;
+    var platform = component.platform;
+    if (!platform.has(name)) {
+        throw new Error("Service ".concat(name, " does not exist"));
+    }
+    var service = platform.get(name);
+    return service[property.service.method](mapState(component, property.name), myOptions);
+}
+function bindFunctions(options, scope) {
+    if (options.filter) {
+        options.filter = options.filter.map(function (func) { return func.bind(scope); });
+    }
+    if (options.map) {
+        options.map = options.map.map(function (func) { return func.bind(scope); });
+    }
+}