vevet 1.4.27 → 2.0.1-dev.3

package/build/cjs/components/page/Page.js

@@ -0,0 +1,353 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+var p_cancelable_1 = __importDefault(require("p-cancelable"));
+var Component_1 = require("../../base/Component");
+/**
+ * Page is a class that may be used to initialize a page.
+ * The reason to use this class is that it allows to set a definite name for the page and manipulate
+ * with its states: creation, show, hide, and destruction.
+ * Notice that the states must be called a definite order: create -> show -> hide -> destroy
+ * and vice versa.
+ */
+var Page = /** @class */ (function (_super) {
+    __extends(Page, _super);
+    function Page(initialProp, init) {
+        if (init === void 0) { init = true; }
+        var _this = _super.call(this, initialProp, false) || this;
+        // set default vars
+        _this._created = false;
+        _this._shown = false;
+        _this._hidden = false;
+        _this._destroyed = false;
+        _this._viaAJAX = false;
+        // initialize the class
+        if (init) {
+            _this.init();
+        }
+        return _this;
+    }
+    Object.defineProperty(Page.prototype, "created", {
+        get: function () {
+            return this._created;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Page.prototype, "shown", {
+        get: function () {
+            return this._shown;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Page.prototype, "hidden", {
+        get: function () {
+            return this._hidden;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Page.prototype, "viaAJAX", {
+        get: function () {
+            return this._viaAJAX;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Page.prototype, "pageClassName", {
+        get: function () {
+            return this._app.prefix + "page-" + this.prop.name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Page.prototype._getDefaultProp = function () {
+        return __assign(__assign({}, _super.prototype._getDefaultProp.call(this)), { name: 'home' });
+    };
+    /**
+     * Create the page.
+     * @param viaAJAX - If the page was loaded through AJAX
+     */
+    Page.prototype.create = function (viaAJAX) {
+        var _this = this;
+        if (viaAJAX === void 0) { viaAJAX = false; }
+        return new Promise(function (resolve, reject) {
+            _this.canCreate().then(function () {
+                if (_this.created) {
+                    return;
+                }
+                // update vars
+                _this._created = true;
+                _this._shown = false;
+                _this._hidden = false;
+                _this._destroyed = false;
+                _this._viaAJAX = viaAJAX;
+                // update page
+                _this._app.page = _this;
+                // add page class
+                _this._app.html.classList.add(_this.pageClassName);
+                // actions
+                _this._create().then(function () {
+                    _this.callbacks.tbt('create', false);
+                    resolve();
+                });
+            }).catch(function () {
+                reject();
+            });
+        });
+    };
+    /**
+     * Use this method to do some actions when creating a page
+     */
+    Page.prototype._create = function () {
+        return new Promise(function (resolve) {
+            resolve();
+        });
+    };
+    /**
+     * Check if the page can be created.
+     */
+    Page.prototype.canCreate = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (!_this.created) {
+                resolve();
+                return;
+            }
+            reject();
+        });
+    };
+    /**
+     * Show the page.
+     */
+    Page.prototype.show = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.canShow().then(function () {
+                if (_this.shown) {
+                    return;
+                }
+                // update vars
+                _this._created = true;
+                _this._shown = true;
+                _this._hidden = false;
+                _this._destroyed = false;
+                // actions
+                _this._show().then(function () {
+                    _this.callbacks.tbt('show', false);
+                    resolve();
+                });
+                // launch events
+            }).catch(function () {
+                reject();
+            });
+        });
+    };
+    /**
+     * Use this method to do some actions when showing a page
+     */
+    Page.prototype._show = function () {
+        return new Promise(function (resolve) {
+            resolve();
+        });
+    };
+    /**
+     * Check if the page can be shown.
+     */
+    Page.prototype.canShow = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (_this.created && !_this.shown) {
+                resolve();
+                return;
+            }
+            reject();
+        });
+    };
+    /**
+     * Hide the page.
+     */
+    Page.prototype.hide = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.canHide().then(function () {
+                if (_this.hidden) {
+                    return;
+                }
+                // update vars
+                _this._created = true;
+                _this._shown = false;
+                _this._hidden = true;
+                _this._destroyed = false;
+                // actions
+                _this._hide().then(function () {
+                    _this.callbacks.tbt('hide', false);
+                    resolve();
+                });
+            }).catch(function () {
+                reject();
+            });
+        });
+    };
+    /**
+     * Use this method to do some actions when hiding a page
+     */
+    Page.prototype._hide = function () {
+        return new Promise(function (resolve) {
+            resolve();
+        });
+    };
+    /**
+     * Check if the page can be hidden.
+     */
+    Page.prototype.canHide = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (_this.created && _this.shown && !_this.hidden) {
+                resolve();
+                return;
+            }
+            reject();
+        });
+    };
+    /**
+     * Destroy the page.
+     */
+    Page.prototype.destroy = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.canDestroy().then(function () {
+                if (_this.destroyed) {
+                    return;
+                }
+                // change vars
+                _this._created = false;
+                _this._shown = false;
+                _this._hidden = true;
+                _this._destroyed = true;
+                // update page
+                _this._app.page = false;
+                // remove page class
+                _this._app.html.classList.remove(_this.pageClassName);
+                // actions
+                _this._destroy().then(function () {
+                    resolve();
+                });
+            }).catch(function () {
+                reject();
+            });
+        });
+    };
+    /**
+     * Use this method to do some actions when destroying a page
+     */
+    Page.prototype._destroy = function () {
+        var _this = this;
+        return new Promise(function (resolve) {
+            _super.prototype._destroy.call(_this);
+            resolve();
+        });
+    };
+    /**
+     * Check if the page can be destroyed.
+     */
+    Page.prototype.canDestroy = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (_this.created && _this.hidden && !_this.destroyed) {
+                resolve();
+                return;
+            }
+            reject();
+        });
+    };
+    /**
+     * Add a 'create' callback.
+     * If the callback was added after the page was created, it will be triggered immediately.
+     */
+    Page.prototype.onCreate = function () {
+        var _this = this;
+        return new p_cancelable_1.default(function (resolve) {
+            if (_this.created) {
+                resolve();
+            }
+            else {
+                _this.addCallback('create', function () {
+                    resolve();
+                }, {
+                    once: true,
+                });
+            }
+        });
+    };
+    /**
+     * Add a 'show' callback.
+     * If the callback was added after the page was shown, it will be triggered immediately.
+     */
+    Page.prototype.onShow = function () {
+        var _this = this;
+        return new p_cancelable_1.default(function (resolve) {
+            if (_this.shown) {
+                resolve();
+            }
+            else {
+                _this.addCallback('show', function () {
+                    resolve();
+                }, {
+                    once: true,
+                });
+            }
+        });
+    };
+    /**
+     * Add a 'hide' callback.
+     * If the callback was added after the page was hidden, it will be triggered immediately.
+     */
+    Page.prototype.onHide = function () {
+        var _this = this;
+        return new p_cancelable_1.default(function (resolve) {
+            if (_this.hidden) {
+                resolve();
+            }
+            else {
+                _this.addCallback('hide', function () {
+                    resolve();
+                }, {
+                    once: true,
+                });
+            }
+        });
+    };
+    return Page;
+}(Component_1.Component));
+exports.Page = Page;