@brandup/ui-app 1.0.1

package/dist/mjs/index.js

@@ -0,0 +1,880 @@
+const ElemAttributeName = "uiElement";
+const ElemPropertyName = "brandupUiElement";
+const CommandAttributeName = "command";
+const CommandExecutingCssClassName = "executing";
+class UIElement {
+    __element = null;
+    __events = {};
+    __commandHandlers = {};
+    // Element members
+    get element() { return this.__element; }
+    setElement(elem) {
+        if (!elem)
+            throw "Not set value elem.";
+        if (this.__element || UIElement.hasElement(elem))
+            throw "UIElement already defined";
+        this.__element = elem;
+        this.__element[ElemPropertyName] = this;
+        this.__element.dataset[ElemAttributeName] = this.typeName;
+        this.defineEvent("command", { cancelable: false, bubbles: true });
+        this._onRenderElement(elem);
+    }
+    // static members
+    static hasElement(elem) {
+        return !!elem.dataset[ElemAttributeName];
+    }
+    // HTMLElement event members
+    defineEvent(eventName, eventOptions) {
+        this.__events[eventName] = eventOptions ? eventOptions : null;
+    }
+    raiseEvent(eventName, eventArgs) {
+        if (!(eventName in this.__events))
+            throw new Error(`Not found event "${eventName}".`);
+        const eventOptions = this.__events[eventName];
+        const eventInit = {};
+        if (eventOptions) {
+            if (eventOptions.bubbles)
+                eventInit.bubbles = eventOptions.bubbles;
+            if (eventOptions.cancelable)
+                eventInit.cancelable = eventOptions.cancelable;
+            if (eventOptions.composed)
+                eventInit.composed = eventOptions.composed;
+        }
+        eventInit.detail = eventArgs ? eventArgs : {};
+        const event = new CustomEvent(eventName, eventInit);
+        return this.dispatchEvent(event);
+    }
+    addEventListener(type, listener, options) {
+        this.__element?.addEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener, options) {
+        this.__element?.removeEventListener(type, listener, options);
+    }
+    dispatchEvent(event) {
+        if (!this.__element)
+            throw new Error("HTMLElement is not defined.");
+        return this.__element.dispatchEvent(event);
+    }
+    // Command members
+    registerCommand(name, execute, canExecute) {
+        name = this.verifyCommandName(name);
+        this.__commandHandlers[name] = {
+            name: name,
+            execute,
+            canExecute,
+            isExecuting: false
+        };
+    }
+    registerAsyncCommand(name, delegate, canExecute) {
+        name = this.verifyCommandName(name);
+        this.__commandHandlers[name] = {
+            name: name,
+            delegate,
+            canExecute,
+            isExecuting: false
+        };
+    }
+    hasCommand(name) {
+        return name.toLowerCase() in this.__commandHandlers;
+    }
+    execCommand(name, elem) {
+        if (!this.__element)
+            throw new Error("UIElement is not set HTMLElement.");
+        const key = name.toLowerCase();
+        if (!(key in this.__commandHandlers))
+            throw new Error(`Command "${name}" is not registered.`);
+        const context = {
+            target: elem,
+            uiElem: this,
+            transparent: false
+        };
+        const handler = this.__commandHandlers[key];
+        if (handler.isExecuting)
+            return { result: CommandsExecStatus.AlreadyExecuting, context };
+        handler.isExecuting = true;
+        if (!this._onCanExecCommand(name, elem)) {
+            handler.isExecuting = false;
+            return { result: CommandsExecStatus.NotAllow, context };
+        }
+        if (handler.canExecute && !handler.canExecute(elem, context)) {
+            handler.isExecuting = false;
+            return { result: CommandsExecStatus.NotAllow, context };
+        }
+        this.raiseEvent("command", {
+            name: handler.name,
+            uiElem: this,
+            elem: this.__element
+        });
+        if (handler.execute) {
+            // Если команда синхронная.
+            try {
+                handler.execute(elem, context);
+            }
+            finally {
+                handler.isExecuting = false;
+            }
+        }
+        else if (handler.delegate) {
+            // Если команда асинхронная.
+            elem.classList.add(CommandExecutingCssClassName);
+            let timeoutId = 0;
+            const endFunc = () => {
+                handler.isExecuting = false;
+                elem.classList.remove(CommandExecutingCssClassName);
+            };
+            const asyncContext = {
+                target: elem,
+                uiElem: this,
+                transparent: context.transparent,
+                complate: () => {
+                    clearTimeout(timeoutId);
+                    endFunc();
+                }
+            };
+            const handlerResult = handler.delegate(asyncContext);
+            if (handlerResult && handlerResult instanceof Promise)
+                handlerResult.finally(() => asyncContext.complate());
+            if (handler.isExecuting && asyncContext.timeout) {
+                timeoutId = window.setTimeout(() => {
+                    if (asyncContext.timeoutCallback)
+                        asyncContext.timeoutCallback();
+                    endFunc();
+                }, asyncContext.timeout);
+            }
+            context.transparent = asyncContext.transparent;
+        }
+        else
+            throw new Error("Not set command execute flow.");
+        return { result: CommandsExecStatus.Success, context: context };
+    }
+    verifyCommandName(name) {
+        const key = name.toLowerCase();
+        if (key in this.__commandHandlers)
+            throw new Error(`Command "${name}" already registered.`);
+        return key;
+    }
+    _onRenderElement(_elem) {
+        return;
+    }
+    _onCanExecCommand(_name, _elem) {
+        return true;
+    }
+    destroy() {
+        const elem = this.__element;
+        if (!elem)
+            return;
+        this.__element = null;
+        delete elem.dataset[ElemAttributeName];
+        delete elem[ElemPropertyName];
+    }
+}
+var CommandsExecStatus;
+(function (CommandsExecStatus) {
+    CommandsExecStatus[CommandsExecStatus["NotAllow"] = 1] = "NotAllow";
+    CommandsExecStatus[CommandsExecStatus["AlreadyExecuting"] = 2] = "AlreadyExecuting";
+    CommandsExecStatus[CommandsExecStatus["Success"] = 3] = "Success";
+})(CommandsExecStatus || (CommandsExecStatus = {}));
+const fundUiElementByCommand = (elem, commandName) => {
+    while (elem) {
+        if (elem.dataset[ElemAttributeName]) {
+            const uiElem = elem[ElemPropertyName];
+            if (uiElem.hasCommand(commandName))
+                return uiElem;
+        }
+        if (typeof elem.parentElement === "undefined")
+            elem = elem.parentNode;
+        else if (elem.parentElement)
+            elem = elem.parentElement;
+        else
+            break;
+    }
+    return null;
+};
+const commandClickHandler = (e) => {
+    let commandElem = e.target;
+    while (commandElem) {
+        if (commandElem.dataset[CommandAttributeName])
+            break;
+        if (commandElem === e.currentTarget)
+            return;
+        commandElem = commandElem.parentElement;
+    }
+    if (!commandElem)
+        return;
+    const commandName = commandElem.dataset[CommandAttributeName];
+    if (!commandName)
+        throw new Error("Command data attribute is not have value.");
+    const uiElem = fundUiElementByCommand(commandElem, commandName);
+    if (uiElem === null) {
+        console.warn(`Not find handler for command "${commandName}".`);
+    }
+    else {
+        const commandResult = uiElem.execCommand(commandName, commandElem);
+        if (commandResult.context.transparent)
+            return;
+    }
+    e.preventDefault();
+    e.stopPropagation();
+    e.stopImmediatePropagation();
+};
+window.addEventListener("click", commandClickHandler, false);
+
+class MiddlewareInvoker {
+    middleware;
+    __next = null;
+    constructor(middleware) {
+        this.middleware = middleware;
+    }
+    next(middleware) {
+        if (this.__next)
+            this.__next.next(middleware);
+        else
+            this.__next = new MiddlewareInvoker(middleware);
+    }
+    async invoke(method, context) {
+        try {
+            await this.__invoke(method, context);
+        }
+        catch (e) {
+            console.error(`Error middleware "${method}" execution: ${e}`);
+            throw e;
+        }
+    }
+    async __invoke(method, context) {
+        const nextFunc = () => { return this.__next ? this.__next.__invoke(method, context) : Promise.resolve(); };
+        const methodFunc = this.middleware[method];
+        if (typeof methodFunc === "function") {
+            const methodResult = methodFunc.call(this.middleware, context, nextFunc);
+            if (!methodResult || !(methodResult instanceof Promise))
+                throw new Error(`Middleware method "${method}" is not async.`);
+            await methodResult;
+        }
+        else
+            await nextFunc();
+    }
+}
+
+const result = {
+    LoadingElementClass: "loading",
+    NavUrlClassName: "applink",
+    FormClassName: "appform",
+    NavUrlAttributeName: "data-nav-url",
+    NavUrlReplaceAttributeName: "data-nav-replace",
+    NavIgnoreAttributeName: "data-nav-ignore",
+    STATE_CLASS: {
+        LOADING: "bp-state-loading",
+        LOADED: "bp-state-loaded",
+        READY: "bp-state-ready"
+    }
+};
+
+var constants = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: result
+});
+
+const STATE_MIDDLEWARE_NAME = "app-state";
+const StateMiddlewareFactory = () => {
+    let counter = 0;
+    const begin = (context) => {
+        counter++;
+        context.app.element?.classList.remove(result.STATE_CLASS.LOADED);
+        context.app.element?.classList.add(result.STATE_CLASS.LOADING);
+    };
+    const end = (context) => {
+        counter--;
+        if (counter <= 0) {
+            counter = 0;
+            context.app.element?.classList.remove(result.STATE_CLASS.LOADING);
+            context.app.element?.classList.add(result.STATE_CLASS.LOADED);
+        }
+    };
+    return {
+        name: STATE_MIDDLEWARE_NAME,
+        start: async (context, next) => {
+            begin(context);
+            try {
+                await next();
+            }
+            catch (reason) {
+                end(context);
+                throw reason;
+            }
+        },
+        loaded: async (context, next) => {
+            try {
+                await next();
+                context.app.element?.classList.add(result.STATE_CLASS.READY);
+            }
+            catch (reason) {
+                end(context);
+                throw reason;
+            }
+        },
+        navigate: async (context, next) => {
+            begin(context);
+            try {
+                await next();
+            }
+            finally {
+                if (context.source == "first")
+                    end(context);
+                end(context);
+            }
+        },
+        submit: async (context, next) => {
+            try {
+                await next();
+            }
+            finally {
+                end(context);
+            }
+        },
+        stop: async (_context, next) => {
+            await next();
+        }
+    };
+};
+
+const win = window;
+const doc = window.document;
+const body = doc.body;
+const loc = window.location;
+var BROWSER = {
+    window: win,
+    document: doc,
+    body,
+    location: loc,
+    reload: () => loc.reload()
+};
+
+var browser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: BROWSER
+});
+
+const HYPERLINK_MIDDLEWARE_NAME = "app-hyperlink";
+const HyperLinkMiddlewareFactory = () => {
+    let __ctrlPressed = false;
+    const onKeyDownUp = (e) => {
+        __ctrlPressed = e.ctrlKey;
+    };
+    let onClick;
+    return {
+        name: HYPERLINK_MIDDLEWARE_NAME,
+        start: async (context, next) => {
+            await next();
+            BROWSER.window.addEventListener("click", onClick = (e) => {
+                let elem = e.target;
+                let ignore = false;
+                while (elem) {
+                    if (elem instanceof Element) {
+                        if (elem.hasAttribute(result.NavIgnoreAttributeName)) {
+                            ignore = true;
+                            break;
+                        }
+                        if (elem.classList && elem.classList.contains(result.NavUrlClassName))
+                            break;
+                    }
+                    if (elem === e.currentTarget)
+                        return;
+                    elem = elem.parentElement;
+                }
+                if (!elem || __ctrlPressed || elem.getAttribute("target") === "_blank")
+                    return;
+                e.preventDefault();
+                e.stopPropagation();
+                if (ignore)
+                    return;
+                let url;
+                if (elem.tagName === "A")
+                    url = elem.getAttribute("href");
+                else if (elem.hasAttribute(result.NavUrlAttributeName))
+                    url = elem.getAttribute(result.NavUrlAttributeName);
+                else
+                    throw "Not found url for navigation.";
+                if (elem.classList.contains(result.LoadingElementClass))
+                    return;
+                elem.classList.add(result.LoadingElementClass);
+                context.app
+                    .nav({ url, replace: elem.hasAttribute(result.NavUrlReplaceAttributeName), data: { clickElem: elem } })
+                    .finally(() => elem.classList.remove(result.LoadingElementClass));
+            }, false);
+            BROWSER.window.addEventListener("keydown", onKeyDownUp, false);
+            BROWSER.window.addEventListener("keyup", onKeyDownUp, false);
+        },
+        stop: (_context, next) => {
+            BROWSER.window.removeEventListener("click", onClick, false);
+            BROWSER.window.removeEventListener("keydown", onKeyDownUp, false);
+            BROWSER.window.removeEventListener("keyup", onKeyDownUp, false);
+            return next();
+        }
+    };
+};
+
+const FORM_MIDDLEWARE_NAME = "app-form";
+const FormMiddlewareFactory = () => {
+    let onWindowSubmit;
+    return {
+        name: FORM_MIDDLEWARE_NAME,
+        start: async (context, next) => {
+            await next();
+            BROWSER.window.addEventListener("submit", onWindowSubmit = (e) => {
+                const form = e.target;
+                if (!form.classList.contains(result.FormClassName))
+                    return;
+                e.preventDefault();
+                context.app.submit({ form, button: e.submitter instanceof HTMLButtonElement ? e.submitter : null });
+            }, false);
+        },
+        submit: async (context, next) => {
+            const { form, button, method } = context;
+            if (!form.checkValidity())
+                return Promise.reject('Form is invalid.');
+            if (form.classList.contains(result.LoadingElementClass))
+                return form["_submit_"];
+            form.classList.add(result.LoadingElementClass);
+            if (button)
+                button.classList.add(result.LoadingElementClass);
+            context.replace = form.hasAttribute(result.NavUrlReplaceAttributeName);
+            if (button && button.hasAttribute(result.NavUrlReplaceAttributeName))
+                context.replace = true;
+            try {
+                if (method === "GET")
+                    await context.app.nav({ url: context.url, query: new FormData(form), data: context.data });
+                else
+                    await next();
+            }
+            finally {
+                form.classList.remove(result.LoadingElementClass);
+                if (button)
+                    button.classList.remove(result.LoadingElementClass);
+            }
+        },
+        stop: (_context, next) => {
+            BROWSER.window.removeEventListener("submit", onWindowSubmit, false);
+            return next();
+        }
+    };
+};
+
+const parseUrl = (url) => {
+    const loc = BROWSER.location;
+    let origin = loc.origin;
+    let path;
+    let query = null;
+    let hash = null;
+    let isExternal = false;
+    if (!url) {
+        path = loc.pathname;
+        if (loc.search)
+            query = new URLSearchParams(loc.search);
+        if (loc.hash)
+            hash = loc.hash;
+    }
+    else {
+        if (url.startsWith("#")) {
+            path = loc.pathname;
+            query = new URLSearchParams(loc.search);
+            hash = url;
+        }
+        else if (url.startsWith("?")) {
+            const hastIndex = url.lastIndexOf("#");
+            if (hastIndex !== -1) {
+                hash = url.substring(hastIndex);
+                url = url.substring(0, hastIndex);
+            }
+            path = loc.pathname;
+            query = new URLSearchParams(url);
+        }
+        else if (url.startsWith("http")) {
+            const u = new URL(url);
+            if (u.origin != origin) {
+                origin = u.origin;
+                isExternal = true;
+            }
+            path = u.pathname;
+            query = u.searchParams;
+            hash = u.hash || null;
+        }
+        else {
+            const hastIndex = url.lastIndexOf("#");
+            if (hastIndex !== -1) {
+                hash = url.substring(hastIndex);
+                url = url.substring(0, hastIndex);
+            }
+            const queryIndex = url.lastIndexOf("?");
+            if (queryIndex !== -1) {
+                query = new URLSearchParams(url.substring(queryIndex));
+                url = url.substring(0, queryIndex);
+            }
+            path = url;
+            if (!path.startsWith("/")) {
+                let curPath = loc.pathname;
+                if (curPath.endsWith("/"))
+                    curPath = curPath.substring(0, curPath.length - 1);
+                path = curPath + "/" + path;
+            }
+        }
+    }
+    if (!path)
+        path = "/";
+    else if (path.length > 1 && path.endsWith("/"))
+        path = path.substring(0, path.length - 1);
+    if (!query)
+        query = new URLSearchParams();
+    if (hash === "#")
+        hash = null;
+    else if (hash)
+        hash = hash.substring(1);
+    var result = {
+        full: "",
+        relative: "",
+        origin,
+        path,
+        query,
+        hash,
+        external: isExternal
+    };
+    rebuildUrl(result);
+    return result;
+};
+/**
+ * Add or replace query parameters.
+ * @param url Source url for extending query.
+ * @param query New or update parameters.
+ */
+const extendQuery = (url, query) => {
+    if (query instanceof URLSearchParams) {
+        query.forEach((v, k) => url.query.delete(k));
+        query.forEach((v, k) => url.query.append(k, v));
+    }
+    else if (query instanceof FormData) {
+        query.forEach((v, k) => url.query.delete(k));
+        query.forEach((v, k) => url.query.append(k, v.toString()));
+    }
+    else {
+        for (let key in query) {
+            const value = query[key];
+            if (!Array.isArray(value)) {
+                url.query.set(key, value);
+            }
+            else {
+                url.query.delete(key);
+                value.forEach(val => url.query.append(key, val));
+            }
+        }
+    }
+    rebuildUrl(url);
+};
+const rebuildUrl = (url) => {
+    let relativeUrl = url.path;
+    if (url.query.size)
+        relativeUrl += "?" + url.query.toString();
+    if (url.hash)
+        relativeUrl += "#" + url.hash;
+    url.full = url.origin + relativeUrl;
+    url.relative = relativeUrl;
+};
+const buildUrl = (basePath, path, query, hash) => {
+    let url = basePath;
+    if (path) {
+        if (path.startsWith("/"))
+            path = path.substring(1);
+        url += path;
+    }
+    if (query) {
+        let params;
+        if (query instanceof URLSearchParams)
+            params = query;
+        else if (query instanceof FormData) {
+            params = new URLSearchParams();
+            query.forEach((value, key) => params.append(key, value.toString()));
+        }
+        else {
+            params = new URLSearchParams();
+            for (const key in query) {
+                const value = query[key];
+                if (value === null || typeof value === "undefined")
+                    continue;
+                if (Array.isArray(value))
+                    value.forEach(v => params.append(key, v));
+                else
+                    params.append(key, value);
+            }
+        }
+        if (params.size)
+            url += "?" + params.toString();
+    }
+    if (hash) {
+        if (!hash.startsWith("#"))
+            hash = "#" + hash;
+        if (hash != "#")
+            url += hash;
+    }
+    return url;
+};
+var urlHelper = {
+    parseUrl,
+    extendQuery,
+    buildUrl
+};
+
+var url = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: urlHelper
+});
+
+/**
+ * Base application class.
+ */
+class Application extends UIElement {
+    env;
+    model;
+    __invoker;
+    __isInitialized = false;
+    __isDestroy = false;
+    __middlewares = {};
+    __lastNav = null;
+    constructor(env, model) {
+        super();
+        this.env = env;
+        this.model = model;
+        const core = { name: "app-root" };
+        this.__invoker = new MiddlewareInvoker(core);
+    }
+    get typeName() { return "Application"; }
+    /** Middleware methods invoker. */
+    get invoker() { return this.__invoker; }
+    /**
+     * @param middlewares Initialize application with middlewares. Using in ApplicationBuilder.
+     */
+    initialize(middlewares) {
+        if (this.__isInitialized)
+            throw 'Application already initialized.';
+        this.__isInitialized = true;
+        this.onInitialize();
+        middlewares.forEach(middleware => {
+            var name = middleware.name;
+            if (this.__middlewares.hasOwnProperty(name))
+                throw `Middleware "${name}" already registered.`;
+            this.__middlewares[name] = middleware;
+            this.__invoker.next(middleware);
+        });
+    }
+    onInitialize() {
+        this.__invoker.next(StateMiddlewareFactory());
+        this.__invoker.next(HyperLinkMiddlewareFactory());
+        this.__invoker.next(FormMiddlewareFactory());
+    }
+    /**
+     * Get middleware by type.
+     * @param type Type of middleware.
+     * @returns Middleware instance.
+     */
+    middleware(name) {
+        const middleware = this.__middlewares[name];
+        if (!middleware)
+            throw `Middleware ${name} is not registered.`;
+        return middleware;
+    }
+    /**
+     * Run application.
+     * @param contextData Run context data.
+     * @param element HTMLElement of application. Default is document.body.
+     * @returns Promise of runned result.
+     */
+    async run(contextData, element) {
+        if (!contextData)
+            contextData = {};
+        this.setElement(element || BROWSER.body);
+        try {
+            const context = {
+                app: this,
+                data: contextData
+            };
+            await this.__invoker.invoke("start", context);
+            console.info("app start success");
+            await this.__invoker.invoke("loaded", context);
+            console.info("app load success");
+            return await this.nav({ data: context.data });
+        }
+        catch (reason) {
+            console.error(`Unable to run application with reason: ${reason}`);
+            throw reason;
+        }
+        finally {
+            console.info("app runned");
+        }
+    }
+    /**
+     * Navigate application to url.
+     * @param options Navigate options.
+     * @returns Promise of navigated result.
+     */
+    async nav(options) {
+        const opt = (!options || options instanceof String) ? { url: options } : options;
+        let { url = null, replace = false, data = {}, callback } = opt;
+        const navUrl = urlHelper.parseUrl(url);
+        if (opt.query)
+            urlHelper.extendQuery(navUrl, opt.query);
+        const isFirst = !this.__lastNav;
+        const context = this.__lastNav = {
+            app: this,
+            source: isFirst ? "first" : "nav",
+            data,
+            url: navUrl.full,
+            origin: navUrl.origin,
+            path: navUrl.path,
+            query: navUrl.query,
+            hash: navUrl.hash,
+            replace,
+            external: navUrl.external
+        };
+        console.info(context);
+        try {
+            console.info(`app nav begin ${navUrl.full}`);
+            await this.__invoker.invoke("navigate", context);
+            if (callback)
+                callback({ status: "success", context: context });
+            console.info(`app nav success ${navUrl.full}`);
+            return context;
+        }
+        catch (reason) {
+            if (callback)
+                callback({ status: "error", context: context });
+            console.error(`app nav error ${navUrl.full}: ${reason}`);
+            throw reason;
+        }
+    }
+    /**
+     * Submit application form.
+     * @param options Submit options.
+     * @returns Promise of submitted result.
+     */
+    async submit(options) {
+        const opt = options instanceof HTMLFormElement ? { form: options } : options;
+        const { form, button = null, query, data = {}, callback = null } = opt;
+        let method = form.method;
+        let enctype = form.enctype;
+        let url = form.action;
+        if (button) {
+            // Get button patameters for request
+            if (button.hasAttribute("formmethod"))
+                method = button.formMethod;
+            if (button.hasAttribute("formenctype"))
+                enctype = button.formEnctype;
+            if (button.hasAttribute("formaction"))
+                url = button.formAction;
+        }
+        method = method.toUpperCase();
+        const navUrl = urlHelper.parseUrl(url);
+        if (query)
+            urlHelper.extendQuery(navUrl, query);
+        let submitContext = {
+            app: this,
+            source: "submit",
+            data,
+            form,
+            button,
+            method,
+            enctype,
+            url: navUrl.full,
+            origin: navUrl.origin,
+            path: navUrl.path,
+            query: navUrl.query,
+            hash: navUrl.hash,
+            replace: false,
+            external: navUrl.external
+        };
+        try {
+            console.info(`submit ${method} begin ${navUrl.full}`);
+            await this.__invoker.invoke("submit", submitContext);
+            console.info(`submit ${method} success ${navUrl.full}`);
+            if (callback)
+                callback({ status: "success", context: submitContext });
+        }
+        catch (reason) {
+            console.error(`submit ${method} error ${navUrl.full} reason: ${reason}`);
+            if (callback)
+                callback({ status: "error", context: submitContext });
+            throw reason;
+        }
+        return submitContext;
+    }
+    /**
+     * Reload page with nav.
+     */
+    reload() {
+        return this.nav({ replace: true });
+    }
+    /**
+     * Global reload page in browser.
+     */
+    restart() {
+        BROWSER.reload();
+    }
+    async destroy(contextData) {
+        if (this.__isDestroy)
+            return Promise.reject('Application already destroyed.');
+        this.__isDestroy = true;
+        console.info("app destroy begin");
+        const context = {
+            app: this,
+            data: contextData || {}
+        };
+        try {
+            await this.__invoker.invoke("stop", context);
+            console.info("app destroy success");
+            return context;
+        }
+        catch (reason) {
+            console.error(`app destroy error: ${reason}`);
+            throw reason;
+        }
+    }
+    /**
+     * Generate url of application base url.
+     * @param path Add optional path of base url.
+     * @param query Add optional query params.
+     * @param hash Add optional hash.
+     * @returns Relative url with base path.
+     */
+    buildUrl(path, query, hash) {
+        return urlHelper.buildUrl(this.env.basePath, path, query, hash);
+    }
+}
+
+class ApplicationBuilder {
+    __appType = (Application);
+    __middlewares = [];
+    useApp(appType) {
+        this.__appType = appType;
+        return this;
+    }
+    useMiddleware(middleware, ...params) {
+        if (!middleware)
+            throw `Middleware propery is required.`;
+        let midl;
+        if (typeof middleware === "function")
+            midl = middleware(...params);
+        else
+            midl = middleware;
+        this.__middlewares.push(midl);
+        return this;
+    }
+    build(env, model) {
+        if (!env)
+            throw new Error("Parameter env is required.");
+        if (!model)
+            throw new Error("Parameter model is required.");
+        if (!env.basePath)
+            env.basePath = "/";
+        const app = new this.__appType(env, model);
+        app.initialize(this.__middlewares);
+        return app;
+    }
+}
+
+export { Application, ApplicationBuilder, browser as BROWSER, constants as CONSTANTS, url as UrlHelper };
+//# sourceMappingURL=index.js.map