397 lines
12 KiB
TypeScript
397 lines
12 KiB
TypeScript
|
|
export declare interface AppConfig {
|
|
registerLoadingPage?: boolean;
|
|
loadingPageStyle?: () => object;
|
|
loadingPageHook?: (view: any) => void;
|
|
launchedHook?: () => void;
|
|
animation?: startAnimationRule;
|
|
}
|
|
|
|
export declare interface appletConfig {
|
|
animationDuration?: number;
|
|
}
|
|
|
|
export declare function assertDeepObject(object: objectAny): boolean;
|
|
|
|
export declare function assertNewOptions<T extends InstantiateConfig>(options: T): T | never;
|
|
|
|
export declare function assertParentChild(parentPath: string, vueVim: any): boolean;
|
|
|
|
export declare type backTypeRule = 'backbutton' | 'navigateBack';
|
|
|
|
export declare function baseClone<T extends {
|
|
[key: string]: any;
|
|
}, K extends keyof T>(source: T, target: Array<any> | objectAny): Array<any> | objectAny | null;
|
|
|
|
export declare function copyData<T>(object: T): T;
|
|
|
|
export declare function createRouter(params: InstantiateConfig): Router;
|
|
|
|
export declare interface debuggerArrayConfig {
|
|
error?: boolean;
|
|
warn?: boolean;
|
|
log?: boolean;
|
|
}
|
|
|
|
export declare type debuggerConfig = boolean | debuggerArrayConfig;
|
|
|
|
export declare function deepClone<T>(source: T): T;
|
|
|
|
export declare function deepDecodeQuery(query: objectAny): objectAny;
|
|
|
|
export declare function def(defObject: objectAny, key: string, getValue: Function): void;
|
|
|
|
export declare interface endAnimationRule {
|
|
animationType?: endAnimationType;
|
|
animationDuration?: number;
|
|
}
|
|
|
|
export declare type endAnimationType = 'slide-out-right' | 'slide-out-left' | 'slide-out-top' | 'slide-out-bottom' | 'pop-out' | 'fade-out' | 'zoom-in' | 'zoom-fade-in' | 'none';
|
|
|
|
export declare function forMatNextToFrom<T extends totalNextRoute>(router: Router, to: T, from: T): {
|
|
matTo: T;
|
|
matFrom: T;
|
|
};
|
|
|
|
export declare function getDataType<T>(data: T): string;
|
|
|
|
export declare function getRoutePath(route: RoutesRule, router: Router): {
|
|
finallyPath: string | string[];
|
|
aliasPath: string;
|
|
path: string;
|
|
alias: string | string[] | undefined;
|
|
};
|
|
|
|
export declare function getUniCachePage<T extends objectAny>(pageIndex?: number): T | [];
|
|
|
|
export declare function getWildcardRule(router: Router, msg?: navErrorRule): RoutesRule | never;
|
|
|
|
export declare type guardHookRule = (to: totalNextRoute, from: totalNextRoute, next: (rule?: navtoRule | false) => void) => void;
|
|
|
|
export declare interface H5Config {
|
|
paramsToQuery?: boolean;
|
|
vueRouterDev?: boolean;
|
|
vueNext?: boolean;
|
|
mode?: string;
|
|
base?: string;
|
|
linkActiveClass?: string;
|
|
linkExactActiveClass?: string;
|
|
scrollBehavior?: Function;
|
|
fallback?: boolean;
|
|
}
|
|
|
|
export declare interface h5NextRule {
|
|
fullPath?: string | undefined;
|
|
hash?: string | undefined;
|
|
matched?: Array<object>;
|
|
meta?: object;
|
|
name?: undefined | string;
|
|
type?: undefined | string;
|
|
}
|
|
|
|
export declare type hookListRule = Array<(router: Router, to: totalNextRoute, from: totalNextRoute, toRoute: RoutesRule, next: Function) => void>;
|
|
|
|
export declare interface hookObjectRule {
|
|
options: Array<any>;
|
|
hook: Function;
|
|
}
|
|
|
|
declare type hookRule = (args: Array<any>, next: (args: Array<any>) => void, router: Router) => void;
|
|
|
|
export declare enum hookToggle {
|
|
'beforeHooks' = "beforeEach",
|
|
'afterHooks' = "afterEach",
|
|
'enterHooks' = "beforeEnter"
|
|
}
|
|
|
|
export declare interface InstantiateConfig {
|
|
[key: string]: any;
|
|
keepUniOriginNav?: boolean;
|
|
platform: platformRule;
|
|
h5?: H5Config;
|
|
APP?: AppConfig;
|
|
applet?: appletConfig;
|
|
beforeProxyHooks?: proxyHooksConfig;
|
|
debugger?: debuggerConfig;
|
|
routerBeforeEach?: (to: navtoRule, from: navtoRule, next: (rule?: navtoRule | false) => void) => void;
|
|
routerAfterEach?: (to: navtoRule, from: navtoRule, next?: Function) => void;
|
|
routerErrorEach?: (error: navErrorRule, router: Router) => void;
|
|
resolveQuery?: (jsonQuery: objectAny) => objectAny;
|
|
parseQuery?: (jsonQuery: objectAny) => objectAny;
|
|
detectBeforeLock?: (router: Router, to: string | number | totalNextRoute | navRoute, navType: NAVTYPE) => void;
|
|
routes: RoutesRule[];
|
|
}
|
|
|
|
export declare interface LifeCycleConfig {
|
|
beforeHooks: hookListRule;
|
|
afterHooks: hookListRule;
|
|
routerBeforeHooks: hookListRule;
|
|
routerAfterHooks: hookListRule;
|
|
routerErrorHooks: Array<(error: navErrorRule, router: Router) => void>;
|
|
}
|
|
|
|
export declare function lockDetectWarn(router: Router, to: string | number | totalNextRoute | navRoute, navType: NAVTYPE, next: Function, uniActualData?: uniBackApiRule | uniBackRule | undefined, passiveType?: 'beforeHooks' | 'afterHooks'): void;
|
|
|
|
export declare function mergeConfig<T extends InstantiateConfig>(baseConfig: T, userConfig: T): T;
|
|
|
|
export declare interface navErrorRule {
|
|
type: navRuleStatus;
|
|
msg: string;
|
|
to?: totalNextRoute;
|
|
from?: totalNextRoute;
|
|
nextTo?: any;
|
|
[propName: string]: any;
|
|
}
|
|
|
|
export declare type navMethodRule = Promise<void | undefined | navRuleStatus>;
|
|
|
|
export declare interface navRoute extends h5NextRule, navtoRule {
|
|
}
|
|
|
|
export declare type navRuleStatus = 0 | 1 | 2 | 3;
|
|
|
|
export declare interface navtoRule {
|
|
NAVTYPE?: NAVTYPE;
|
|
path?: string;
|
|
name?: string | undefined;
|
|
query?: objectAny;
|
|
params?: objectAny;
|
|
animationType?: startAnimationType | endAnimationType;
|
|
animationDuration?: number;
|
|
events?: objectAny;
|
|
success?: Function;
|
|
fail?: Function;
|
|
complete?: Function;
|
|
}
|
|
|
|
export declare type NAVTYPE = 'push' | 'replace' | 'replaceAll' | 'pushTab' | 'back';
|
|
|
|
export declare enum navtypeToggle {
|
|
'push' = "navigateTo",
|
|
'replace' = "redirectTo",
|
|
'replaceAll' = "reLaunch",
|
|
'pushTab' = "switchTab",
|
|
'back' = "navigateBack"
|
|
}
|
|
|
|
export declare function notDeepClearNull<T>(object: T): T;
|
|
|
|
export declare function notRouteTo404(router: Router, toRoute: RoutesRule | {
|
|
redirect: any;
|
|
path: string;
|
|
}, parseToRule: totalNextRoute, navType: NAVTYPE): RoutesRule | totalNextRoute | never;
|
|
|
|
export declare type objectAny = {
|
|
[propName: string]: any;
|
|
};
|
|
|
|
export declare interface originMixins extends uniNavApiRule {
|
|
BACKTYPE: '' | backTypeRule;
|
|
}
|
|
|
|
export declare type pageTypeRule = 'app' | 'page' | 'component';
|
|
|
|
export declare function paramsToQuery(router: Router, toRule: totalNextRoute | string): totalNextRoute | string;
|
|
|
|
export declare type platformRule = 'h5' | 'app-plus' | 'app-lets' | 'mp-weixin' | 'mp-baidu' | 'mp-alipay' | 'mp-toutiao' | 'mp-qq' | 'mp-360';
|
|
|
|
export declare type PromiseResolve = (value?: void | PromiseLike<void> | undefined) => void;
|
|
|
|
export declare type proxyDepsRule = {
|
|
resetIndex: Array<number>;
|
|
hooks: {
|
|
[key: number]: {
|
|
proxyHook: () => void;
|
|
callHook: (enterPath: string) => void;
|
|
resetHook: () => void;
|
|
};
|
|
};
|
|
options: {
|
|
[key: number]: Array<any>;
|
|
};
|
|
};
|
|
|
|
export declare type proxyHookName = 'beforeHooks' | 'afterHooks';
|
|
|
|
export declare interface proxyHooksConfig {
|
|
onLaunch?: hookRule;
|
|
onShow?: hookRule;
|
|
onHide?: hookRule;
|
|
onError?: hookRule;
|
|
onInit?: hookRule;
|
|
onLoad?: hookRule;
|
|
onReady?: hookRule;
|
|
onUnload?: hookRule;
|
|
onResize?: hookRule;
|
|
destroyed?: hookRule;
|
|
created?: hookRule;
|
|
beforeCreate?: hookRule;
|
|
beforeMount?: hookRule;
|
|
mounted?: hookRule;
|
|
beforeDestroy?: hookRule;
|
|
}
|
|
|
|
export declare type reloadNavRule = totalNextRoute | false | undefined | string;
|
|
|
|
export declare function removeSimpleValue(array: Array<string | number>, value: string): Boolean;
|
|
|
|
export declare type reNavMethodRule = 'navigateTo' | 'redirectTo' | 'reLaunch' | 'switchTab';
|
|
|
|
export declare type reNotNavMethodRule = 'navigateBack';
|
|
|
|
export declare function resolveAbsolutePath(path: string, router: Router): string | never;
|
|
|
|
export declare enum rewriteMethodToggle {
|
|
'navigateTo' = "push",
|
|
'navigate' = "push",
|
|
'redirectTo' = "replace",
|
|
'reLaunch' = "replaceAll",
|
|
'switchTab' = "pushTab",
|
|
'navigateBack' = "back"
|
|
}
|
|
|
|
export declare interface Router {
|
|
readonly lifeCycle: LifeCycleConfig;
|
|
readonly options: InstantiateConfig;
|
|
$lockStatus: boolean;
|
|
$route: object | null;
|
|
enterPath: string;
|
|
runId: number;
|
|
Vue: any;
|
|
appMain: {
|
|
NAVTYPE: reNavMethodRule | reNotNavMethodRule;
|
|
path: string;
|
|
} | {};
|
|
proxyHookDeps: proxyDepsRule;
|
|
routesMap: routesMapRule | {};
|
|
mount: Array<{
|
|
app: any;
|
|
el: string;
|
|
}>;
|
|
install(Vue: any): void;
|
|
push(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
|
|
replace(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
|
|
replaceAll(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
|
|
pushTab(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
|
|
back(level: number | undefined, origin?: uniBackRule | uniBackApiRule): void;
|
|
forceGuardEach(navType: NAVTYPE | undefined, forceNav: boolean): void;
|
|
beforeEach(userGuard: guardHookRule): void;
|
|
afterEach(userGuard: (to: totalNextRoute, from: totalNextRoute) => void): void;
|
|
}
|
|
|
|
export declare function RouterMount(Vim: any, router: Router, el?: string | undefined): void | never;
|
|
|
|
export declare interface routeRule {
|
|
name: string | undefined;
|
|
meta: objectAny;
|
|
path: string;
|
|
query: objectAny;
|
|
params: objectAny;
|
|
fullPath: string;
|
|
NAVTYPE: NAVTYPE | '';
|
|
BACKTYPE?: backTypeRule | '';
|
|
[propName: string]: any;
|
|
}
|
|
|
|
export declare function routesForMapRoute(router: Router, path: string, mapArrayKey: Array<routesMapKeysRule>, deepFind?: boolean | undefined): RoutesRule | never;
|
|
|
|
export declare type routesMapKeysRule = 'finallyPathList' | 'finallyPathMap' | 'aliasPathMap' | 'pathMap' | 'nameMap' | 'vueRouteMap';
|
|
|
|
export declare interface routesMapRule {
|
|
[key: string]: any;
|
|
finallyPathList: Array<string>;
|
|
finallyPathMap: RoutesRule;
|
|
aliasPathMap: RoutesRule;
|
|
pathMap: RoutesRule;
|
|
nameMap: RoutesRule;
|
|
vueRouteMap: objectAny;
|
|
}
|
|
|
|
export declare interface RoutesRule {
|
|
path: string;
|
|
component?: object;
|
|
name?: string;
|
|
components?: object;
|
|
redirect?: string | Function;
|
|
props?: boolean | object | Function;
|
|
aliasPath?: string;
|
|
alias?: string | Array<string>;
|
|
children?: Array<RoutesRule>;
|
|
beforeEnter?: guardHookRule;
|
|
meta?: any;
|
|
[propName: string]: any;
|
|
}
|
|
|
|
export declare function runtimeQuit(title?: string | undefined): void;
|
|
|
|
export declare interface startAnimationRule {
|
|
animationType?: startAnimationType;
|
|
animationDuration?: number;
|
|
}
|
|
|
|
export declare type startAnimationType = 'slide-in-right' | 'slide-in-left' | 'slide-in-top' | 'slide-in-bottom' | 'pop-in' | 'fade-in' | 'zoom-out' | 'zoom-fade-out' | 'none';
|
|
|
|
export declare function timeOut(time: number): Promise<void>;
|
|
|
|
export declare interface totalNextRoute extends h5NextRule, navtoRule {
|
|
path: string;
|
|
delta?: number;
|
|
[propName: string]: any;
|
|
}
|
|
|
|
export declare interface uniBackApiRule {
|
|
delta?: number;
|
|
animationDuration?: number;
|
|
animationType?: endAnimationType;
|
|
}
|
|
|
|
export declare interface uniBackRule {
|
|
from: backTypeRule;
|
|
}
|
|
|
|
export declare interface uniNavApiRule {
|
|
url: string;
|
|
openType?: 'appLaunch';
|
|
query?: objectAny;
|
|
path?: string;
|
|
delta?: number;
|
|
detail?: {
|
|
[propName: string]: any;
|
|
};
|
|
animationType?: startAnimationType;
|
|
animationDuration?: number;
|
|
events?: {
|
|
[propName: string]: any;
|
|
};
|
|
success?: Function;
|
|
fail?: Function;
|
|
complete?: Function;
|
|
animation?: {
|
|
animationType?: startAnimationType;
|
|
animationDuration?: number;
|
|
};
|
|
}
|
|
|
|
export declare function urlToJson(url: string): {
|
|
path: string;
|
|
query: objectAny;
|
|
};
|
|
|
|
export declare function voidFun(...args: any): void;
|
|
|
|
export declare type vueHookNameRule = 'onLaunch' | 'onShow' | 'onHide' | 'onError' | 'onInit' | 'onLoad' | 'onReady' | 'onUnload' | 'onResize' | 'created' | 'beforeMount' | 'mounted' | 'beforeDestroy' | 'destroyed';
|
|
|
|
export declare type vueOptionRule = {
|
|
[propName in vueHookNameRule]: Array<Function> | undefined;
|
|
};
|
|
|
|
export { }
|
|
|
|
// @ts-ignore
|
|
declare module 'vue/types/vue' {
|
|
interface Vue {
|
|
$Router: Router;
|
|
$Route: routeRule;
|
|
}
|
|
}
|
|
|