rezor 0.0.0 → 0.0.2

package/dist/index.cjs.js

@@ -0,0 +1,1240 @@
+/*!
+ * rezor v0.0.2
+ * https://github.com/rezorjs/rezor
+ * (c) 2026-present Yang Mingshan
+ * @license MIT
+ */
+'use strict';
+
+let currentApp = null;
+function setCurrentApp(app) {
+    currentApp = app;
+}
+function unsetCurrentApp() {
+    currentApp = null;
+}
+let currentPage = null;
+function setCurrentPage(page) {
+    currentPage = page;
+}
+function unsetCurrentPage() {
+    currentPage = null;
+}
+let currentComponent = null;
+function setCurrentComponent(component) {
+    currentComponent = component;
+}
+function unsetCurrentComponent() {
+    currentComponent = null;
+}
+function getCurrentInstance() {
+    return currentPage || currentComponent;
+}
+function getCurrentInstanceAll() {
+    return currentApp || currentPage || currentComponent;
+}
+
+function getHooksStore(instance) {
+    if (instance.__hooks__ === undefined) {
+        instance.__hooks__ = { cursor: 0, slots: [] };
+    }
+    return instance.__hooks__;
+}
+function resetHooksCursor(instance) {
+    const store = instance.__hooks__;
+    if (store === undefined) {
+        return;
+    }
+    store.cursor = 0;
+}
+function trimHooksStore(instance) {
+    const store = instance.__hooks__;
+    if (store === undefined) {
+        return;
+    }
+    store.slots.length = store.cursor;
+}
+function isHookKind(slot, kind) {
+    return slot !== undefined && slot.kind === kind;
+}
+function resetLifecycleCursors(instance, lifecycles) {
+    const store = instance.__lifecycle__;
+    if (store === undefined) {
+        return;
+    }
+    lifecycles.forEach((lifecycle) => {
+        if (store[lifecycle] !== undefined) {
+            store[lifecycle].cursor = 0;
+        }
+    });
+}
+function trimLifecycleBuckets(instance, lifecycles) {
+    const store = instance.__lifecycle__;
+    if (store === undefined) {
+        return;
+    }
+    lifecycles.forEach((lifecycle) => {
+        if (store[lifecycle] !== undefined) {
+            store[lifecycle].handlers.length = store[lifecycle].cursor;
+        }
+    });
+}
+function registerLifecycleHook(instance, lifecycle, hook) {
+    if (instance.__lifecycle__ === undefined) {
+        instance.__lifecycle__ = {};
+    }
+    const store = instance.__lifecycle__;
+    if (store[lifecycle] === undefined) {
+        store[lifecycle] = { cursor: 0, handlers: [] };
+    }
+    const bucket = store[lifecycle];
+    bucket.handlers[bucket.cursor] = hook;
+    bucket.cursor += 1;
+}
+function getLifecycleCursor(instance, lifecycle) {
+    const store = instance.__lifecycle__;
+    if (store === undefined || store[lifecycle] === undefined) {
+        return 0;
+    }
+    return store[lifecycle].cursor;
+}
+function getLifecycleHooks(instance, lifecycle) {
+    const store = instance.__lifecycle__;
+    if (store === undefined || store[lifecycle] === undefined) {
+        return [];
+    }
+    return store[lifecycle].handlers;
+}
+
+function useRef(initialValue) {
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        const store = getHooksStore(currentInstance);
+        const index = store.cursor;
+        let refSlot = store.slots[index];
+        if (!isHookKind(refSlot, 'ref')) {
+            refSlot = { kind: 'ref', ref: { current: initialValue } };
+            store.slots[index] = refSlot;
+        }
+        store.cursor += 1;
+        return refSlot.ref;
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useRef() hook can only be called during execution of render().');
+    }
+    return { current: initialValue };
+}
+
+const extend = Object.assign;
+function exclude(obj, keys) {
+    const ret = {};
+    Object.keys(obj).forEach((key) => {
+        if (!keys.includes(key)) {
+            ret[key] = obj[key];
+        }
+    });
+    return ret;
+}
+function isFunction(x) {
+    return typeof x === 'function';
+}
+function areHookDepsEqual(prevDeps, nextDeps) {
+    if (prevDeps === undefined || nextDeps === undefined) {
+        return false;
+    }
+    if (nextDeps.length !== prevDeps.length) {
+        return false;
+    }
+    for (let i = 0; i < nextDeps.length; i++) {
+        if (!Object.is(nextDeps[i], prevDeps[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+var SchedulerJobFlags;
+(function (SchedulerJobFlags) {
+    SchedulerJobFlags[SchedulerJobFlags["QUEUED"] = 1] = "QUEUED";
+    SchedulerJobFlags[SchedulerJobFlags["DISPOSED"] = 2] = "DISPOSED";
+})(SchedulerJobFlags || (SchedulerJobFlags = {}));
+const jobs = [];
+let postJobs = [];
+let activePostJobs = null;
+let currentFlushPromise = null;
+let jobsLength = 0;
+let flushIndex = 0;
+let postFlushIndex = 0;
+const resolvedPromise = /*@__PURE__*/ Promise.resolve();
+const RECURSION_LIMIT = 100;
+function nextTick(fn) {
+    const p = currentFlushPromise || resolvedPromise;
+    return fn ? p.then(fn) : p;
+}
+function queueJob(job) {
+    if (queueJobWorker(job, jobs, jobsLength)) {
+        jobsLength++;
+        queueFlush();
+    }
+}
+function queueJobWorker(job, queue, length) {
+    const flags = job.flags;
+    if (!(flags & SchedulerJobFlags.QUEUED)) {
+        job.flags = flags | SchedulerJobFlags.QUEUED;
+        queue[length] = job;
+        return true;
+    }
+    return false;
+}
+function queueFlush() {
+    if (!currentFlushPromise) {
+        // We don't flush post jobs on flushJobs's finally block, so we don't need `doFlushJobs` here.
+        currentFlushPromise = resolvedPromise.then(flushJobs);
+    }
+}
+function queuePostFlushCb(job) {
+    queueJobWorker(job, postJobs, postJobs.length);
+}
+function flushPostFlushCbs() {
+    if (postJobs.length) {
+        activePostJobs = postJobs;
+        postJobs = [];
+        try {
+            while (postFlushIndex < activePostJobs.length) {
+                const cb = activePostJobs[postFlushIndex++];
+                if (!(cb.flags & SchedulerJobFlags.DISPOSED)) {
+                    cb.flags &= ~SchedulerJobFlags.QUEUED;
+                    cb();
+                }
+            }
+        }
+        finally {
+            // If there was an error we still need to clear the QUEUED flags
+            while (postFlushIndex < activePostJobs.length) {
+                activePostJobs[postFlushIndex++].flags &= ~SchedulerJobFlags.QUEUED;
+            }
+            activePostJobs = null;
+            postFlushIndex = 0;
+        }
+    }
+}
+function flushJobs() {
+    let seen;
+    /* istanbul ignore else -- @preserve */
+    {
+        seen = new Map();
+    }
+    try {
+        while (flushIndex < jobsLength) {
+            const job = jobs[flushIndex];
+            jobs[flushIndex++] = undefined;
+            if (!(job.flags & SchedulerJobFlags.DISPOSED)) {
+                // Conditional usage of checkRecursiveUpdate must be determined out of
+                // try ... catch block since Rollup by default de-optimizes treeshaking
+                // inside try-catch. This can leave all warning code unshaked. Although
+                // they would get eventually shaken by a minifier like terser, some minifiers
+                // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610)
+                /* istanbul ignore if -- @preserve  */
+                if (true && checkRecursiveUpdates(seen, job)) {
+                    continue;
+                }
+                job.flags &= ~SchedulerJobFlags.QUEUED;
+                job();
+            }
+        }
+    }
+    finally {
+        // If there was an error we still need to clear the QUEUED flags
+        while (flushIndex < jobsLength) {
+            jobs[flushIndex].flags &= ~SchedulerJobFlags.QUEUED;
+            jobs[flushIndex++] = undefined;
+        }
+        flushIndex = 0;
+        jobsLength = 0;
+        currentFlushPromise = null;
+    }
+}
+function checkRecursiveUpdates(seen, fn) {
+    const count = seen.get(fn) || 0;
+    /* istanbul ignore if -- @preserve */
+    if (count > RECURSION_LIMIT) {
+        console.warn(`Maximum recursive updates exceeded. ` +
+            `This usually means a state update is being triggered inside render(), ` +
+            `causing an infinite loop.`);
+        return true;
+    }
+    seen.set(fn, count + 1);
+    return false;
+}
+
+function useState(initialState) {
+    const getState = () => isFunction(initialState) ? initialState() : initialState;
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        const store = getHooksStore(currentInstance);
+        const index = store.cursor;
+        let stateSlot = store.slots[index];
+        if (!isHookKind(stateSlot, 'state')) {
+            const setState = (newState) => {
+                const prevState = stateSlot.value;
+                const nextState = isFunction(newState) ? newState(prevState) : newState;
+                if (Object.is(prevState, nextState)) {
+                    return;
+                }
+                stateSlot.value = nextState;
+                queueJob(currentInstance.__render__);
+            };
+            stateSlot = { kind: 'state', value: getState(), setState };
+            store.slots[index] = stateSlot;
+        }
+        store.cursor += 1;
+        return [stateSlot.value, stateSlot.setState];
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useState() hook can only be called during execution of render().');
+    }
+    return [getState(), () => { }];
+}
+
+function useReducer(reducer, initialArg, init) {
+    const getState = () => init === undefined ? initialArg : init(initialArg);
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        const store = getHooksStore(currentInstance);
+        const index = store.cursor;
+        let stateSlot = store.slots[index];
+        if (!isHookKind(stateSlot, 'state')) {
+            const dispatch = (action) => {
+                const prevState = stateSlot.value;
+                const nextState = reducer(prevState, action);
+                if (Object.is(prevState, nextState)) {
+                    return;
+                }
+                stateSlot.value = nextState;
+                queueJob(currentInstance.__render__);
+            };
+            stateSlot = {
+                kind: 'state',
+                value: getState(),
+                setState: dispatch,
+            };
+            store.slots[index] = stateSlot;
+        }
+        store.cursor += 1;
+        return [stateSlot.value, stateSlot.setState];
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useReducer() hook can only be called during execution of render().');
+    }
+    return [getState(), () => { }];
+}
+
+function memoImpl(currentInstance, factory, deps) {
+    const store = getHooksStore(currentInstance);
+    const index = store.cursor;
+    let memoSlot = store.slots[index];
+    if (!isHookKind(memoSlot, 'memo')) {
+        memoSlot = { kind: 'memo', value: factory(), deps };
+        store.slots[index] = memoSlot;
+    }
+    else if (!areHookDepsEqual(memoSlot.deps, deps)) {
+        memoSlot.value = factory();
+        memoSlot.deps = deps;
+    }
+    store.cursor += 1;
+    return memoSlot.value;
+}
+function useMemo(factory, deps) {
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        return memoImpl(currentInstance, factory, deps);
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useMemo() hook can only be called during execution of render().');
+    }
+    return factory();
+}
+function useCallback(callback, deps) {
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        return memoImpl(currentInstance, () => callback, deps);
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useCallback() hook can only be called during execution of render().');
+    }
+    return callback;
+}
+
+function useEffectEvent(callback) {
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        const store = getHooksStore(currentInstance);
+        const index = store.cursor;
+        let effectEventSlot = store.slots[index];
+        if (!isHookKind(effectEventSlot, 'effectEvent')) {
+            effectEventSlot = { kind: 'effectEvent', fn: callback };
+            store.slots[index] = effectEventSlot;
+        }
+        else {
+            effectEventSlot.fn = callback;
+        }
+        store.cursor += 1;
+        return ((...args) => effectEventSlot.fn(...args));
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useEffectEvent() hook can only be called during execution of render().');
+    }
+    return callback;
+}
+
+function effectImpl(currentInstance, queue, callback, deps) {
+    const store = getHooksStore(currentInstance);
+    const index = store.cursor;
+    let effectSlot = store.slots[index];
+    if (!isHookKind(effectSlot, 'effect')) {
+        effectSlot = { kind: 'effect', deps, cleanup: undefined };
+        store.slots[index] = effectSlot;
+        const job = () => {
+            effectSlot.job = undefined;
+            effectSlot.cleanup = callback();
+        };
+        effectSlot.job = job;
+        queue(job);
+    }
+    else if (!areHookDepsEqual(effectSlot.deps, deps)) {
+        effectSlot.deps = deps;
+        const job = () => {
+            effectSlot.job = undefined;
+            if (effectSlot.cleanup) {
+                effectSlot.cleanup();
+            }
+            effectSlot.cleanup = callback();
+        };
+        effectSlot.job = job;
+        queue(job);
+    }
+    store.cursor += 1;
+}
+function useEffect(callback, deps) {
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        effectImpl(currentInstance, queuePostFlushCb, callback, deps);
+        return;
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useEffect() hook can only be called during execution of render().');
+    }
+}
+function useRenderEffect(callback, deps) {
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        effectImpl(currentInstance, queueJob, callback, deps);
+        return;
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useRenderEffect() hook can only be called during execution of render().');
+    }
+}
+
+function createContext(defaultValue) {
+    return {
+        defaultValue,
+        currentValue: defaultValue,
+        subscribers: new Set(),
+        provider: null,
+    };
+}
+function notifyContextSubscribers(context) {
+    context.subscribers.forEach((job) => {
+        queueJob(job);
+    });
+}
+function useContext(context, value) {
+    const currentInstance = getCurrentInstanceAll();
+    if (currentInstance) {
+        const store = getHooksStore(currentInstance);
+        const index = store.cursor;
+        if (arguments.length >= 2) {
+            // Provider
+            if (!isHookKind(store.slots[index], 'context')) {
+                // It maybe invalid now, but become valid in a later render.
+                // So we need to reserve a slot for it and add cleanup logic.
+                store.slots[index] = {
+                    kind: 'context',
+                    cleanup: () => {
+                        if (context.provider === currentInstance) {
+                            context.provider = null;
+                            if (!Object.is(context.currentValue, context.defaultValue)) {
+                                context.currentValue = context.defaultValue;
+                                notifyContextSubscribers(context);
+                            }
+                        }
+                    },
+                };
+            }
+            if (context.provider !== null && context.provider !== currentInstance) {
+                /* istanbul ignore else -- @preserve  */
+                {
+                    console.warn('useContext() does not support multiple providers for the same context at the same time.');
+                }
+                store.cursor += 1;
+                return;
+            }
+            context.provider = currentInstance;
+            if (!Object.is(context.currentValue, value)) {
+                context.currentValue = value;
+                notifyContextSubscribers(context);
+            }
+            store.cursor += 1;
+            return;
+        }
+        // Consumer
+        const render = currentInstance.__render__;
+        if (!isHookKind(store.slots[index], 'context')) {
+            store.slots[index] = {
+                kind: 'context',
+                cleanup() {
+                    context.subscribers.delete(render);
+                },
+            };
+        }
+        context.subscribers.add(render);
+        store.cursor += 1;
+        return context.currentValue;
+    }
+    /* istanbul ignore else -- @preserve  */
+    {
+        console.warn('useContext() hook can only be called during execution of render().');
+    }
+    return context.currentValue;
+}
+
+var AppLifecycle;
+(function (AppLifecycle) {
+    AppLifecycle["ON_LAUNCH"] = "onLaunch";
+    AppLifecycle["ON_SHOW"] = "onShow";
+    AppLifecycle["ON_HIDE"] = "onHide";
+    AppLifecycle["ON_ERROR"] = "onError";
+    AppLifecycle["ON_PAGE_NOT_FOUND"] = "onPageNotFound";
+    AppLifecycle["ON_UNHANDLED_REJECTION"] = "onUnhandledRejection";
+    AppLifecycle["ON_THEME_CHANGE"] = "onThemeChange";
+})(AppLifecycle || (AppLifecycle = {}));
+const appLifeHooks = [
+    AppLifecycle.ON_SHOW,
+    AppLifecycle.ON_HIDE,
+    AppLifecycle.ON_ERROR,
+    AppLifecycle.ON_PAGE_NOT_FOUND,
+    AppLifecycle.ON_UNHANDLED_REJECTION,
+    AppLifecycle.ON_THEME_CHANGE,
+];
+function createApp(optionsOrRender) {
+    let render;
+    let options;
+    if (isFunction(optionsOrRender)) {
+        render = optionsOrRender;
+        options = {};
+    }
+    else {
+        if (optionsOrRender.render === undefined) {
+            App(optionsOrRender);
+            return;
+        }
+        render = optionsOrRender.render;
+        options = exclude(optionsOrRender, ['render']);
+    }
+    const originOnLaunch = options[AppLifecycle.ON_LAUNCH];
+    options[AppLifecycle.ON_LAUNCH] = function (options) {
+        this.__render__ = () => {
+            setCurrentApp(this);
+            resetHooksCursor(this);
+            resetLifecycleCursors(this, appLifeHooks);
+            try {
+                const bindings = render(options);
+                if (bindings !== undefined) {
+                    Object.keys(bindings).forEach((key) => {
+                        this[key] = bindings[key];
+                    });
+                }
+            }
+            finally {
+                unsetCurrentApp();
+            }
+            trimHooksStore(this);
+            trimLifecycleBuckets(this, appLifeHooks);
+        };
+        this.__render__();
+        if (originOnLaunch !== undefined) {
+            originOnLaunch.call(this, options);
+        }
+    };
+    options[AppLifecycle.ON_SHOW] = createLifecycle$2(options, AppLifecycle.ON_SHOW);
+    options[AppLifecycle.ON_HIDE] = createLifecycle$2(options, AppLifecycle.ON_HIDE);
+    options[AppLifecycle.ON_ERROR] = createLifecycle$2(options, AppLifecycle.ON_ERROR);
+    options[AppLifecycle.ON_PAGE_NOT_FOUND] = createLifecycle$2(options, AppLifecycle.ON_PAGE_NOT_FOUND);
+    options[AppLifecycle.ON_UNHANDLED_REJECTION] = createLifecycle$2(options, AppLifecycle.ON_UNHANDLED_REJECTION);
+    options[AppLifecycle.ON_THEME_CHANGE] = createLifecycle$2(options, AppLifecycle.ON_THEME_CHANGE);
+    App(options);
+}
+function createLifecycle$2(options, lifecycle) {
+    const originLifecycle = options[lifecycle];
+    return function (...args) {
+        getLifecycleHooks(this, lifecycle).forEach((hook) => hook(...args));
+        if (originLifecycle !== undefined) {
+            originLifecycle.call(this, ...args);
+        }
+    };
+}
+
+var PageLifecycle;
+(function (PageLifecycle) {
+    PageLifecycle["ON_LOAD"] = "onLoad";
+    PageLifecycle["ON_SHOW"] = "onShow";
+    PageLifecycle["ON_READY"] = "onReady";
+    PageLifecycle["ON_HIDE"] = "onHide";
+    PageLifecycle["ON_UNLOAD"] = "onUnload";
+    PageLifecycle["ON_ROUTE_DONE"] = "onRouteDone";
+    PageLifecycle["ON_PULL_DOWN_REFRESH"] = "onPullDownRefresh";
+    PageLifecycle["ON_REACH_BOTTOM"] = "onReachBottom";
+    PageLifecycle["ON_PAGE_SCROLL"] = "onPageScroll";
+    PageLifecycle["ON_SHARE_APP_MESSAGE"] = "onShareAppMessage";
+    PageLifecycle["ON_SHARE_TIMELINE"] = "onShareTimeline";
+    PageLifecycle["ON_ADD_TO_FAVORITES"] = "onAddToFavorites";
+    PageLifecycle["ON_RESIZE"] = "onResize";
+    PageLifecycle["ON_TAB_ITEM_TAP"] = "onTabItemTap";
+    PageLifecycle["ON_SAVE_EXIT_STATE"] = "onSaveExitState";
+})(PageLifecycle || (PageLifecycle = {}));
+const pageLifeHooks = [
+    PageLifecycle.ON_SHOW,
+    PageLifecycle.ON_HIDE,
+    PageLifecycle.ON_ROUTE_DONE,
+    PageLifecycle.ON_PULL_DOWN_REFRESH,
+    PageLifecycle.ON_REACH_BOTTOM,
+    PageLifecycle.ON_PAGE_SCROLL,
+    PageLifecycle.ON_SHARE_APP_MESSAGE,
+    PageLifecycle.ON_SHARE_TIMELINE,
+    PageLifecycle.ON_ADD_TO_FAVORITES,
+    PageLifecycle.ON_RESIZE,
+    PageLifecycle.ON_TAB_ITEM_TAP,
+    PageLifecycle.ON_SAVE_EXIT_STATE,
+];
+function definePage(optionsOrRender, config) {
+    config = extend({
+        listenPageScroll: false,
+        canShareToOthers: false,
+        canShareToTimeline: false,
+    }, config);
+    let render;
+    let options;
+    if (isFunction(optionsOrRender)) {
+        render = optionsOrRender;
+        options = {};
+    }
+    else {
+        if (optionsOrRender.render === undefined) {
+            Page(optionsOrRender);
+            return;
+        }
+        render = optionsOrRender.render;
+        options = exclude(optionsOrRender, ['render']);
+    }
+    const originOnLoad = options[PageLifecycle.ON_LOAD];
+    options[PageLifecycle.ON_LOAD] = function (query) {
+        const context = {
+            is: this.is,
+            route: this.route,
+            options: this.options,
+            exitState: this.exitState,
+            router: this.router,
+            pageRouter: this.pageRouter,
+            renderer: this.renderer,
+            createSelectorQuery: this.createSelectorQuery.bind(this),
+            createIntersectionObserver: this.createIntersectionObserver.bind(this),
+            createMediaQueryObserver: this.createMediaQueryObserver.bind(this),
+            selectComponent: this.selectComponent.bind(this),
+            selectAllComponents: this.selectAllComponents.bind(this),
+            getTabBar: this.getTabBar.bind(this),
+            getPageId: this.getPageId.bind(this),
+            animate: this.animate.bind(this),
+            clearAnimation: this.clearAnimation.bind(this),
+            getOpenerEventChannel: this.getOpenerEventChannel.bind(this),
+            applyAnimatedStyle: this.applyAnimatedStyle.bind(this),
+            clearAnimatedStyle: this.clearAnimatedStyle.bind(this),
+            setUpdatePerformanceListener: this.setUpdatePerformanceListener.bind(this),
+            getPassiveEvent: this.getPassiveEvent.bind(this),
+            setPassiveEvent: this.setPassiveEvent.bind(this),
+            setInitialRenderingCache: this.setInitialRenderingCache.bind(this),
+            getAppBar: this.getAppBar && this.getAppBar.bind(this),
+        };
+        this.__render__ = () => {
+            setCurrentPage(this);
+            resetHooksCursor(this);
+            resetLifecycleCursors(this, pageLifeHooks);
+            try {
+                const bindings = render(query, context);
+                if (bindings !== undefined) {
+                    let data;
+                    Object.keys(bindings).forEach((key) => {
+                        const value = bindings[key];
+                        if (isFunction(value)) {
+                            this[key] = value;
+                            return;
+                        }
+                        if (!Object.prototype.hasOwnProperty.call(this.data, key) ||
+                            !Object.is(this.data[key], value)) {
+                            data = data || {};
+                            data[key] = value;
+                        }
+                    });
+                    if (data !== undefined) {
+                        this.setData(data, flushPostFlushCbs);
+                    }
+                }
+            }
+            finally {
+                unsetCurrentPage();
+            }
+            trimHooksStore(this);
+            trimLifecycleBuckets(this, pageLifeHooks);
+        };
+        this.__render__();
+        if (originOnLoad !== undefined) {
+            originOnLoad.call(this, query);
+        }
+    };
+    const originOnReady = options[PageLifecycle.ON_READY];
+    options[PageLifecycle.ON_READY] = function () {
+        flushPostFlushCbs();
+        if (originOnReady !== undefined) {
+            originOnReady.call(this);
+        }
+    };
+    const originOnUnload = options[PageLifecycle.ON_UNLOAD];
+    options[PageLifecycle.ON_UNLOAD] = function () {
+        const renderJob = this.__render__;
+        renderJob.flags |= SchedulerJobFlags.DISPOSED;
+        const store = getHooksStore(this);
+        store.slots.forEach((slot) => {
+            if (slot.kind === 'effect') {
+                if (slot.job) {
+                    slot.job.flags |= SchedulerJobFlags.DISPOSED;
+                    slot.job = undefined;
+                }
+                if (slot.cleanup) {
+                    slot.cleanup();
+                }
+            }
+            else if (slot.kind === 'context') {
+                slot.cleanup();
+            }
+        });
+        if (originOnUnload !== undefined) {
+            originOnUnload.call(this);
+        }
+    };
+    if (options[PageLifecycle.ON_PAGE_SCROLL] || config.listenPageScroll) {
+        options[PageLifecycle.ON_PAGE_SCROLL] = createLifecycle$1(options, PageLifecycle.ON_PAGE_SCROLL);
+        /* istanbul ignore next -- @preserve */
+        options.__listenPageScroll__ = () => true;
+    }
+    if (options[PageLifecycle.ON_SHARE_APP_MESSAGE] === undefined &&
+        config.canShareToOthers) {
+        options[PageLifecycle.ON_SHARE_APP_MESSAGE] = createReturnLifecycle$1(PageLifecycle.ON_SHARE_APP_MESSAGE, () => ({}));
+        /* istanbul ignore next -- @preserve */
+        options.__isInjectedShareToOthersHook__ = () => true;
+    }
+    if (options[PageLifecycle.ON_SHARE_TIMELINE] === undefined &&
+        config.canShareToTimeline) {
+        options[PageLifecycle.ON_SHARE_TIMELINE] = createReturnLifecycle$1(PageLifecycle.ON_SHARE_TIMELINE, () => ({}));
+        /* istanbul ignore next -- @preserve */
+        options.__isInjectedShareToTimelineHook__ = () => true;
+    }
+    if (options[PageLifecycle.ON_ADD_TO_FAVORITES] === undefined) {
+        options[PageLifecycle.ON_ADD_TO_FAVORITES] = createReturnLifecycle$1(PageLifecycle.ON_ADD_TO_FAVORITES, () => ({}));
+        /* istanbul ignore next -- @preserve */
+        options.__isInjectedFavoritesHook__ = () => true;
+    }
+    if (options[PageLifecycle.ON_SAVE_EXIT_STATE] === undefined) {
+        options[PageLifecycle.ON_SAVE_EXIT_STATE] = createReturnLifecycle$1(PageLifecycle.ON_SAVE_EXIT_STATE, () => ({ data: undefined }));
+        /* istanbul ignore next -- @preserve */
+        options.__isInjectedExitStateHook__ = () => true;
+    }
+    options[PageLifecycle.ON_SHOW] = createLifecycle$1(options, PageLifecycle.ON_SHOW);
+    options[PageLifecycle.ON_HIDE] = createLifecycle$1(options, PageLifecycle.ON_HIDE);
+    options[PageLifecycle.ON_ROUTE_DONE] = createLifecycle$1(options, PageLifecycle.ON_ROUTE_DONE);
+    options[PageLifecycle.ON_PULL_DOWN_REFRESH] = createLifecycle$1(options, PageLifecycle.ON_PULL_DOWN_REFRESH);
+    options[PageLifecycle.ON_REACH_BOTTOM] = createLifecycle$1(options, PageLifecycle.ON_REACH_BOTTOM);
+    options[PageLifecycle.ON_RESIZE] = createLifecycle$1(options, PageLifecycle.ON_RESIZE);
+    options[PageLifecycle.ON_TAB_ITEM_TAP] = createLifecycle$1(options, PageLifecycle.ON_TAB_ITEM_TAP);
+    Page(options);
+}
+function createLifecycle$1(options, lifecycle) {
+    const originLifecycle = options[lifecycle];
+    return function (...args) {
+        getLifecycleHooks(this, lifecycle).forEach((hook) => hook(...args));
+        if (originLifecycle !== undefined) {
+            originLifecycle.call(this, ...args);
+        }
+    };
+}
+function createReturnLifecycle$1(lifecycle, getDefaultValue) {
+    return function (...args) {
+        const [hook] = getLifecycleHooks(this, lifecycle);
+        if (hook) {
+            return hook(...args);
+        }
+        return getDefaultValue();
+    };
+}
+
+var ComponentLifecycle;
+(function (ComponentLifecycle) {
+    ComponentLifecycle["ATTACHED"] = "attached";
+    ComponentLifecycle["READY"] = "ready";
+    ComponentLifecycle["MOVED"] = "moved";
+    ComponentLifecycle["DETACHED"] = "detached";
+    ComponentLifecycle["ERROR"] = "error";
+})(ComponentLifecycle || (ComponentLifecycle = {}));
+const specialLifecycleMap = {
+    [PageLifecycle.ON_SHOW]: 'show',
+    [PageLifecycle.ON_HIDE]: 'hide',
+    [PageLifecycle.ON_RESIZE]: 'resize',
+    [PageLifecycle.ON_ROUTE_DONE]: 'routeDone',
+};
+const componentLifeHooks = [
+    ...pageLifeHooks,
+    ComponentLifecycle.MOVED,
+    ComponentLifecycle.ERROR,
+];
+function defineComponent(optionsOrRender, config) {
+    config = extend({
+        listenPageScroll: false,
+        canShareToOthers: false,
+        canShareToTimeline: false,
+    }, config);
+    let render;
+    let options;
+    let properties = null;
+    if (isFunction(optionsOrRender)) {
+        render = optionsOrRender;
+        options = {};
+    }
+    else {
+        if (optionsOrRender.render === undefined) {
+            return Component(optionsOrRender);
+        }
+        render = optionsOrRender.render;
+        options = exclude(optionsOrRender, ['render']);
+        if (options.properties) {
+            properties = Object.keys(options.properties);
+        }
+    }
+    if (options.lifetimes === undefined) {
+        options.lifetimes = {};
+    }
+    const originAttached = options.lifetimes[ComponentLifecycle.ATTACHED] ||
+        options[ComponentLifecycle.ATTACHED];
+    options.lifetimes[ComponentLifecycle.ATTACHED] = function () {
+        this.__props__ = {};
+        if (properties) {
+            properties.forEach((property) => {
+                this.__props__[property] = this.data[property];
+            });
+        }
+        const context = {
+            is: this.is,
+            id: this.id,
+            dataset: this.dataset,
+            exitState: this.exitState,
+            router: this.router,
+            pageRouter: this.pageRouter,
+            renderer: this.renderer,
+            triggerEvent: this.triggerEvent.bind(this),
+            createSelectorQuery: this.createSelectorQuery.bind(this),
+            createIntersectionObserver: this.createIntersectionObserver.bind(this),
+            createMediaQueryObserver: this.createMediaQueryObserver.bind(this),
+            selectComponent: this.selectComponent.bind(this),
+            selectAllComponents: this.selectAllComponents.bind(this),
+            selectOwnerComponent: this.selectOwnerComponent.bind(this),
+            getRelationNodes: this.getRelationNodes.bind(this),
+            getTabBar: this.getTabBar.bind(this),
+            getPageId: this.getPageId.bind(this),
+            animate: this.animate.bind(this),
+            clearAnimation: this.clearAnimation.bind(this),
+            getOpenerEventChannel: this.getOpenerEventChannel.bind(this),
+            applyAnimatedStyle: this.applyAnimatedStyle.bind(this),
+            clearAnimatedStyle: this.clearAnimatedStyle.bind(this),
+            setUpdatePerformanceListener: this.setUpdatePerformanceListener.bind(this),
+            getPassiveEvent: this.getPassiveEvent.bind(this),
+            setPassiveEvent: this.setPassiveEvent.bind(this),
+            setInitialRenderingCache: this.setInitialRenderingCache.bind(this),
+            getAppBar: this.getAppBar && this.getAppBar.bind(this),
+        };
+        this.__render__ = () => {
+            setCurrentComponent(this);
+            resetHooksCursor(this);
+            resetLifecycleCursors(this, componentLifeHooks);
+            try {
+                const bindings = render(this.__props__, context);
+                if (bindings !== undefined) {
+                    let data;
+                    Object.keys(bindings).forEach((key) => {
+                        const value = bindings[key];
+                        if (isFunction(value)) {
+                            this[key] = value;
+                            return;
+                        }
+                        if (!Object.prototype.hasOwnProperty.call(this.data, key) ||
+                            !Object.is(this.data[key], value)) {
+                            data = data || {};
+                            data[key] = value;
+                        }
+                    });
+                    if (data !== undefined) {
+                        this.setData(data, flushPostFlushCbs);
+                    }
+                }
+            }
+            finally {
+                unsetCurrentComponent();
+            }
+            trimHooksStore(this);
+            trimLifecycleBuckets(this, componentLifeHooks);
+        };
+        this.__render__();
+        if (originAttached !== undefined) {
+            originAttached.call(this);
+        }
+    };
+    const originReady = options.lifetimes[ComponentLifecycle.READY] ||
+        options[ComponentLifecycle.READY];
+    options.lifetimes[ComponentLifecycle.READY] = function () {
+        flushPostFlushCbs();
+        if (originReady !== undefined) {
+            originReady.call(this);
+        }
+    };
+    const originDetached = options.lifetimes[ComponentLifecycle.DETACHED] ||
+        options[ComponentLifecycle.DETACHED];
+    options.lifetimes[ComponentLifecycle.DETACHED] = function () {
+        const renderJob = this.__render__;
+        renderJob.flags |= SchedulerJobFlags.DISPOSED;
+        const store = getHooksStore(this);
+        store.slots.forEach((slot) => {
+            if (slot.kind === 'effect') {
+                if (slot.job) {
+                    slot.job.flags |= SchedulerJobFlags.DISPOSED;
+                    slot.job = undefined;
+                }
+                if (slot.cleanup) {
+                    slot.cleanup();
+                }
+            }
+            else if (slot.kind === 'context') {
+                slot.cleanup();
+            }
+        });
+        if (originDetached !== undefined) {
+            originDetached.call(this);
+        }
+    };
+    options.lifetimes[ComponentLifecycle.MOVED] = createComponentLifecycle(options, ComponentLifecycle.MOVED);
+    options.lifetimes[ComponentLifecycle.ERROR] = createComponentLifecycle(options, ComponentLifecycle.ERROR);
+    if (options.methods === undefined) {
+        options.methods = {};
+    }
+    if (options.methods[PageLifecycle.ON_PAGE_SCROLL] ||
+        config.listenPageScroll) {
+        options.methods[PageLifecycle.ON_PAGE_SCROLL] = createPageLifecycle(options, PageLifecycle.ON_PAGE_SCROLL);
+        /* istanbul ignore next -- @preserve */
+        options.methods.__listenPageScroll__ = () => true;
+    }
+    if (options.methods[PageLifecycle.ON_SHARE_APP_MESSAGE] === undefined &&
+        config.canShareToOthers) {
+        options.methods[PageLifecycle.ON_SHARE_APP_MESSAGE] = createReturnLifecycle(PageLifecycle.ON_SHARE_APP_MESSAGE, () => ({}));
+        /* istanbul ignore next -- @preserve */
+        options.methods.__isInjectedShareToOthersHook__ = () => true;
+    }
+    if (options.methods[PageLifecycle.ON_SHARE_TIMELINE] === undefined &&
+        config.canShareToTimeline) {
+        options.methods[PageLifecycle.ON_SHARE_TIMELINE] = createReturnLifecycle(PageLifecycle.ON_SHARE_TIMELINE, () => ({}));
+        /* istanbul ignore next -- @preserve */
+        options.methods.__isInjectedShareToTimelineHook__ = () => true;
+    }
+    if (options.methods[PageLifecycle.ON_ADD_TO_FAVORITES] === undefined) {
+        options.methods[PageLifecycle.ON_ADD_TO_FAVORITES] = createReturnLifecycle(PageLifecycle.ON_ADD_TO_FAVORITES, () => ({}));
+        /* istanbul ignore next -- @preserve */
+        options.methods.__isInjectedFavoritesHook__ = () => true;
+    }
+    if (options.methods[PageLifecycle.ON_SAVE_EXIT_STATE] === undefined) {
+        options.methods[PageLifecycle.ON_SAVE_EXIT_STATE] = createReturnLifecycle(PageLifecycle.ON_SAVE_EXIT_STATE, () => ({ data: undefined }));
+        /* istanbul ignore next -- @preserve */
+        options.methods.__isInjectedExitStateHook__ = () => true;
+    }
+    options.methods[PageLifecycle.ON_PULL_DOWN_REFRESH] = createPageLifecycle(options, PageLifecycle.ON_PULL_DOWN_REFRESH);
+    options.methods[PageLifecycle.ON_REACH_BOTTOM] = createPageLifecycle(options, PageLifecycle.ON_REACH_BOTTOM);
+    options.methods[PageLifecycle.ON_TAB_ITEM_TAP] = createPageLifecycle(options, PageLifecycle.ON_TAB_ITEM_TAP);
+    if (options.pageLifetimes === undefined) {
+        options.pageLifetimes = {};
+    }
+    options.pageLifetimes[specialLifecycleMap[PageLifecycle.ON_SHOW]] =
+        createSpecialPageLifecycle(options, PageLifecycle.ON_SHOW);
+    options.pageLifetimes[specialLifecycleMap[PageLifecycle.ON_HIDE]] =
+        createSpecialPageLifecycle(options, PageLifecycle.ON_HIDE);
+    options.pageLifetimes[specialLifecycleMap[PageLifecycle.ON_RESIZE]] =
+        createSpecialPageLifecycle(options, PageLifecycle.ON_RESIZE);
+    options.pageLifetimes[specialLifecycleMap[PageLifecycle.ON_ROUTE_DONE]] =
+        createSpecialPageLifecycle(options, PageLifecycle.ON_ROUTE_DONE);
+    if (properties) {
+        if (options.observers === undefined) {
+            options.observers = {};
+        }
+        properties.forEach((property) => {
+            const originObserver = options.observers[property];
+            options.observers[property] = function (value) {
+                // Observer executes before attached
+                if (this.__props__) {
+                    this.__props__ = extend({}, this.__props__, { [property]: value });
+                }
+                // Observer executes before attached
+                if (this.__render__) {
+                    queueJob(this.__render__);
+                }
+                if (originObserver !== undefined) {
+                    originObserver.call(this, value);
+                }
+            };
+        });
+    }
+    return Component(options);
+}
+function createComponentLifecycle(options, lifecycle) {
+    const originLifecycle = options.lifetimes[lifecycle] || options[lifecycle];
+    return createLifecycle(lifecycle, originLifecycle);
+}
+function createPageLifecycle(options, lifecycle) {
+    const originLifecycle = options.methods[lifecycle];
+    return createLifecycle(lifecycle, originLifecycle);
+}
+function createSpecialPageLifecycle(options, lifecycle) {
+    const originLifecycle = options.pageLifetimes[specialLifecycleMap[lifecycle]];
+    return createLifecycle(lifecycle, originLifecycle);
+}
+function createLifecycle(lifecycle, originLifecycle) {
+    return function (...args) {
+        getLifecycleHooks(this, lifecycle).forEach((hook) => hook(...args));
+        if (originLifecycle !== undefined) {
+            originLifecycle.call(this, ...args);
+        }
+    };
+}
+function createReturnLifecycle(lifecycle, getDefaultValue) {
+    return function (...args) {
+        const [hook] = getLifecycleHooks(this, lifecycle);
+        if (hook) {
+            return hook(...args);
+        }
+        return getDefaultValue();
+    };
+}
+
+const pageHookWarn = 'Page specific lifecycle hooks can only be used during execution of render() in definePage() or defineComponent().';
+const useAppShow = createAppHook(AppLifecycle.ON_SHOW);
+const useAppHide = createAppHook(AppLifecycle.ON_HIDE);
+const useAppError = createAppHook(AppLifecycle.ON_ERROR);
+const usePageNotFound = createAppHook(AppLifecycle.ON_PAGE_NOT_FOUND);
+const useUnhandledRejection = createAppHook(AppLifecycle.ON_UNHANDLED_REJECTION);
+const useThemeChange = createAppHook(AppLifecycle.ON_THEME_CHANGE);
+const useShow = createPageHook(PageLifecycle.ON_SHOW);
+const useHide = createPageHook(PageLifecycle.ON_HIDE);
+const useRouteDone = createPageHook(PageLifecycle.ON_ROUTE_DONE);
+const usePullDownRefresh = createPageHook(PageLifecycle.ON_PULL_DOWN_REFRESH);
+const useReachBottom = createPageHook(PageLifecycle.ON_REACH_BOTTOM);
+const useResize = createPageHook(PageLifecycle.ON_RESIZE);
+const useTabItemTap = createPageHook(PageLifecycle.ON_TAB_ITEM_TAP);
+const usePageScroll = (hook) => {
+    const currentInstance = getCurrentInstance();
+    /* istanbul ignore else -- @preserve  */
+    if (currentInstance) {
+        /* istanbul ignore else -- @preserve   */
+        if (currentInstance.__listenPageScroll__) {
+            registerLifecycleHook(currentInstance, PageLifecycle.ON_PAGE_SCROLL, hook);
+        }
+        else {
+            console.warn('usePageScroll() hook only works when `listenPageScroll` is configured to true.');
+        }
+    }
+    else {
+        console.warn(pageHookWarn);
+    }
+};
+const useShareAppMessage = (hook) => {
+    const currentInstance = getCurrentInstance();
+    /* istanbul ignore else -- @preserve  */
+    if (currentInstance) {
+        /* istanbul ignore else -- @preserve  */
+        if (currentInstance.__isInjectedShareToOthersHook__) {
+            const cursor = getLifecycleCursor(currentInstance, PageLifecycle.ON_SHARE_APP_MESSAGE);
+            /* istanbul ignore else -- @preserve  */
+            if (cursor === 0) {
+                registerLifecycleHook(currentInstance, PageLifecycle.ON_SHARE_APP_MESSAGE, hook);
+            }
+            else {
+                console.warn('useShareAppMessage() hook can only be called once.');
+            }
+        }
+        else {
+            console.warn('useShareAppMessage() hook only works when `onShareAppMessage` option does not exist and `canShareToOthers` is configured to true.');
+        }
+    }
+    else {
+        console.warn(pageHookWarn);
+    }
+};
+const useShareTimeline = (hook) => {
+    const currentInstance = getCurrentInstance();
+    /* istanbul ignore else -- @preserve  */
+    if (currentInstance) {
+        /* istanbul ignore else -- @preserve  */
+        if (currentInstance.__isInjectedShareToTimelineHook__) {
+            const cursor = getLifecycleCursor(currentInstance, PageLifecycle.ON_SHARE_TIMELINE);
+            /* istanbul ignore else -- @preserve  */
+            if (cursor === 0) {
+                registerLifecycleHook(currentInstance, PageLifecycle.ON_SHARE_TIMELINE, hook);
+            }
+            else {
+                console.warn('useShareTimeline() hook can only be called once.');
+            }
+        }
+        else {
+            console.warn('useShareTimeline() hook only works when `onShareTimeline` option does not exist and `canShareToTimeline` is configured to true.');
+        }
+    }
+    else {
+        console.warn(pageHookWarn);
+    }
+};
+const useAddToFavorites = (hook) => {
+    const currentInstance = getCurrentInstance();
+    /* istanbul ignore else -- @preserve  */
+    if (currentInstance) {
+        /* istanbul ignore else -- @preserve  */
+        if (currentInstance.__isInjectedFavoritesHook__) {
+            const cursor = getLifecycleCursor(currentInstance, PageLifecycle.ON_ADD_TO_FAVORITES);
+            /* istanbul ignore else -- @preserve  */
+            if (cursor === 0) {
+                registerLifecycleHook(currentInstance, PageLifecycle.ON_ADD_TO_FAVORITES, hook);
+            }
+            else {
+                console.warn('useAddToFavorites() hook can only be called once.');
+            }
+        }
+        else {
+            console.warn('useAddToFavorites() hook only works when `onAddToFavorites` option does not exist.');
+        }
+    }
+    else {
+        console.warn(pageHookWarn);
+    }
+};
+const useSaveExitState = (hook) => {
+    const currentInstance = getCurrentInstance();
+    /* istanbul ignore else -- @preserve  */
+    if (currentInstance) {
+        /* istanbul ignore else -- @preserve  */
+        if (currentInstance.__isInjectedExitStateHook__) {
+            const cursor = getLifecycleCursor(currentInstance, PageLifecycle.ON_SAVE_EXIT_STATE);
+            /* istanbul ignore else -- @preserve  */
+            if (cursor === 0) {
+                registerLifecycleHook(currentInstance, PageLifecycle.ON_SAVE_EXIT_STATE, hook);
+            }
+            else {
+                console.warn('useSaveExitState() hook can only be called once.');
+            }
+        }
+        else {
+            console.warn('useSaveExitState() hook only works when `onSaveExitState` option does not exist.');
+        }
+    }
+    else {
+        console.warn(pageHookWarn);
+    }
+};
+const useMove = createComponentHook(ComponentLifecycle.MOVED);
+const useError = createComponentHook(ComponentLifecycle.ERROR);
+function createAppHook(lifecycle) {
+    return (hook) => {
+        /* istanbul ignore else -- @preserve  */
+        if (currentApp) {
+            registerLifecycleHook(currentApp, lifecycle, hook);
+        }
+        else {
+            console.warn('App specific lifecycle hooks can only be used during execution of render() in createApp().');
+        }
+    };
+}
+function createPageHook(lifecycle) {
+    return (hook) => {
+        const currentInstance = getCurrentInstance();
+        /* istanbul ignore else -- @preserve  */
+        if (currentInstance) {
+            registerLifecycleHook(currentInstance, lifecycle, hook);
+        }
+        else {
+            console.warn(pageHookWarn);
+        }
+    };
+}
+function createComponentHook(lifecycle) {
+    return (hook) => {
+        /* istanbul ignore else -- @preserve  */
+        if (currentComponent) {
+            registerLifecycleHook(currentComponent, lifecycle, hook);
+        }
+        else {
+            console.warn('Component specific lifecycle hooks can only be used during execution of render() in defineComponent().');
+        }
+    };
+}
+
+exports.createApp = createApp;
+exports.createContext = createContext;
+exports.defineComponent = defineComponent;
+exports.definePage = definePage;
+exports.nextTick = nextTick;
+exports.useAddToFavorites = useAddToFavorites;
+exports.useAppError = useAppError;
+exports.useAppHide = useAppHide;
+exports.useAppShow = useAppShow;
+exports.useCallback = useCallback;
+exports.useContext = useContext;
+exports.useEffect = useEffect;
+exports.useEffectEvent = useEffectEvent;
+exports.useError = useError;
+exports.useHide = useHide;
+exports.useMemo = useMemo;
+exports.useMove = useMove;
+exports.usePageNotFound = usePageNotFound;
+exports.usePageScroll = usePageScroll;
+exports.usePullDownRefresh = usePullDownRefresh;
+exports.useReachBottom = useReachBottom;
+exports.useReducer = useReducer;
+exports.useRef = useRef;
+exports.useRenderEffect = useRenderEffect;
+exports.useResize = useResize;
+exports.useRouteDone = useRouteDone;
+exports.useSaveExitState = useSaveExitState;
+exports.useShareAppMessage = useShareAppMessage;
+exports.useShareTimeline = useShareTimeline;
+exports.useShow = useShow;
+exports.useState = useState;
+exports.useTabItemTap = useTabItemTap;
+exports.useThemeChange = useThemeChange;
+exports.useUnhandledRejection = useUnhandledRejection;