vite-ssr-middleware/dist/types/index.d.ts

"Middleware support for plugin vite-ssr"

import { Context } from 'vite-ssr/vue/';
import { NavigationGuardNext, RouteLocationNormalized } from 'vue-router';
interface ViteSSRContext extends Context {
}
interface RouterGuard {
    to: RouteLocationNormalized;
    from: RouteLocationNormalized;
    next: NavigationGuardNext;
}
interface HandlerParameters extends RouterGuard {
}
interface MiddlewareHandler {
    (params: ViteSSRContext & RouterGuard, properties: CustomProperties): boolean | Promise<boolean>;
}
export interface Middleware {
    name: string;
    handler: MiddlewareHandler;
}
export declare type MiddlewareRecord = (string | Middleware)[];
export interface CustomProperties {
    [key: string]: any;
}
/**
 *
 * @param name Unique name for middleware
 * @param fn Handler function
 * @param properties Optional properties
 * @example ```ts
   import {defineMiddleware} from 'vite-plugin-middleware'
   const authMiddleware = defineMiddleware('authMiddleware', (context) => true)
 * ```
 */
export declare function defineMiddleware(name: string, fn: MiddlewareHandler): Middleware;
/**
 * @description Creates middleware handler to handle middlewares manually.
 * @param middlewares List of all middlewars
 * @param properties Properties those can be accessible in middlewares
 * @returns Async function that returns a promise<boolean>, if value is true it means `next()` is handled by middlewares, if false it means `next()` is not handled by middlewares
 * @example ```ts
   export default viteSSR(App, {routes}, (context) => {
               const middlewareHandler = createMiddlewareHandler([authMiddleWare]);
               router.beforeEach(async (to, from, next) => {b
                        const isHandled = await middlewareHandler({...params, to, from, next});
                        if (!isHandled) {
                           next();
                        }
                  });
   })
 * ```
 */
export declare function createMiddlewareHandler(context: ViteSSRContext, middlewares: Middleware[], properties?: CustomProperties): (routerContext: HandlerParameters) => Promise<boolean>;
/**
 * @description Single handler that does the job of {@link createMiddlewareHandler} automatically.
 * @see {@link createMiddlewareHandler} Example Code
 * @param context Vite-SSR context
 * @param middlewares Middleware array
 * @param properties Properties those can be accessible in middlewares
 * @returns a function which will be handled by `router.beforeEach`
 * @example ```ts
   export default viteSSR(App, {routes}, (context) => {
               router.beforeEach(middlewareHandler(context, [authMiddleware, someMiddleware]));
   })
 * ```
 */
export declare function middlewareHandler(context: ViteSSRContext, middlewares: Middleware[], properties?: CustomProperties): (to: RouteLocationNormalized, from: RouteLocationNormalized, next: NavigationGuardNext) => Promise<void>;
export {};