@shuvi/platform-shared 1.0.0-rc.0

package/lib/node/route/route.d.ts

@@ -0,0 +1,37 @@
+import { IUserRouteConfig, IApiRouteConfig, IMiddlewareRouteConfig } from '@shuvi/service';
+import { SupportFileType } from './helpers';
+export declare type IPageRouteConfig = IUserRouteConfig;
+export type { IApiRouteConfig, IMiddlewareRouteConfig };
+interface RawFileRoute {
+    kind: 'file';
+    type: SupportFileType;
+    name: string;
+    segment: string;
+    filepath: string;
+}
+interface RawDirRoute {
+    kind: 'dir';
+    filepath: string;
+    segment: string;
+    parentSegment: string;
+    children: (RawFileRoute | RawDirRoute)[];
+}
+declare type RawRoute = RawFileRoute | RawDirRoute;
+export interface RouteException {
+    type: SupportFileType | 'dir';
+    msg: string;
+}
+export interface RouteResult<T> {
+    warnings: RouteException[];
+    errors: RouteException[];
+    routes: T[];
+}
+export declare type RawRoutes = RouteResult<RawRoute>;
+export declare type PageRoutes = RouteResult<IPageRouteConfig>;
+export declare type ApiRoutes = RouteResult<IApiRouteConfig>;
+export declare type MiddlewareRoutes = RouteResult<IMiddlewareRouteConfig>;
+export declare type RouteConfigType = IPageRouteConfig | IApiRouteConfig | IMiddlewareRouteConfig;
+export declare const getRawRoutesFromDir: (dirname: string) => Promise<RawRoutes>;
+export declare const getPageRoutes: (dirname: string) => Promise<PageRoutes>;
+export declare const getApiRoutes: (dir: string) => Promise<ApiRoutes>;
+export declare const getMiddlewareRoutes: (dirname: string) => Promise<MiddlewareRoutes>;

package/lib/node/route/route.js

@@ -0,0 +1,212 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMiddlewareRoutes = exports.getApiRoutes = exports.getPageRoutes = exports.getRawRoutesFromDir = void 0;
+const path_1 = require("path");
+const file_1 = require("@shuvi/utils/lib/file");
+const helpers_1 = require("./helpers");
+const getRawRoutesFromDir = (dirname) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(yield (0, file_1.isDirectory)(dirname))) {
+        return {
+            routes: [],
+            warnings: [],
+            errors: []
+        };
+    }
+    const warnings = [];
+    const errors = [];
+    const _getRawRoutesFromDir = (dirname, rawRoutes, segment) => __awaiter(void 0, void 0, void 0, function* () {
+        const files = yield (0, helpers_1.getAllowFilesAndDirs)(dirname);
+        const onlyHasDir = !(0, helpers_1.hasAllowFiles)(files);
+        if (!files.length) {
+            warnings.push({
+                type: 'dir',
+                msg: `${dirname} is empty dir!`
+            });
+        }
+        for (const file of files) {
+            const filepath = (0, path_1.join)(dirname, file);
+            const isDir = yield (0, file_1.isDirectory)(filepath);
+            if (isDir) {
+                if (onlyHasDir) {
+                    // only indent segment,routes was in same level.
+                    yield _getRawRoutesFromDir(filepath, rawRoutes, `${segment}/${file}`);
+                    continue;
+                }
+                const rawRoute = {
+                    kind: 'dir',
+                    filepath,
+                    segment: (0, helpers_1.normalize)(file).replace(/^\//, ''),
+                    parentSegment: (0, helpers_1.normalize)(segment).replace(/^\//, ''),
+                    children: []
+                };
+                yield _getRawRoutesFromDir(filepath, rawRoute.children, file);
+                rawRoutes.push(rawRoute);
+                continue;
+            }
+            const ext = (0, path_1.extname)(file);
+            const type = (0, path_1.basename)(file, ext);
+            rawRoutes.push({
+                kind: 'file',
+                name: file,
+                segment: (0, helpers_1.normalize)(segment),
+                filepath,
+                type
+            });
+        }
+        return rawRoutes;
+    });
+    const routes = yield _getRawRoutesFromDir(dirname, [], '');
+    return {
+        routes,
+        warnings,
+        errors
+    };
+});
+exports.getRawRoutesFromDir = getRawRoutesFromDir;
+const getPageRoutes = (dirname) => __awaiter(void 0, void 0, void 0, function* () {
+    const { routes: rawRoutes, warnings, errors } = yield (0, exports.getRawRoutesFromDir)(dirname);
+    const _getPageRoutes = (rawRoutes, routes, segment = '') => {
+        const layoutRoute = rawRoutes.some(route => route.kind === 'file' && route.type === 'layout');
+        const route = {};
+        if (layoutRoute) {
+            route.children = [];
+        }
+        for (const rawRoute of rawRoutes) {
+            if (rawRoute.kind === 'dir') {
+                const workRoutes = layoutRoute ? route.children : routes;
+                const preSegment = layoutRoute
+                    ? ''
+                    : `${segment}${rawRoute.parentSegment}/`;
+                _getPageRoutes(rawRoute.children, workRoutes, preSegment);
+            }
+            else if (rawRoute.type === 'page' || rawRoute.type === 'layout') {
+                if (rawRoute.type === 'page' && layoutRoute) {
+                    route.children.push({
+                        path: '',
+                        component: rawRoute.filepath
+                    });
+                }
+                else {
+                    let prefix = segment;
+                    let suffix = rawRoute.segment;
+                    route.component = rawRoute.filepath;
+                    route.path = `${prefix}${suffix}`;
+                    routes.push(Object.assign({}, route));
+                }
+            }
+        }
+        return routes;
+    };
+    const routes = (0, helpers_1.sortRoutes)(_getPageRoutes(rawRoutes, []));
+    routes.forEach(route => {
+        if (!route.path.startsWith('/')) {
+            route.path = `/${route.path}`;
+        }
+    });
+    return {
+        routes,
+        warnings,
+        errors
+    };
+});
+exports.getPageRoutes = getPageRoutes;
+const getApiRoutes = (dir) => __awaiter(void 0, void 0, void 0, function* () {
+    const getConflictWaring = (rawRoute, conflictRawRoute) => {
+        return `Find both ${(0, path_1.basename)(conflictRawRoute.filepath)} and ${(0, path_1.basename)(rawRoute.filepath)} in "${(0, path_1.dirname)(rawRoute.filepath)}"!, only "${(0, path_1.basename)(conflictRawRoute.filepath)}" is used.`;
+    };
+    const { routes: rawRoutes, warnings, errors } = yield (0, exports.getRawRoutesFromDir)(dir);
+    const _getApiRoutes = (rawRoutes, routes, prefix = '') => {
+        const page = rawRoutes.find(route => route.kind === 'file' && route.type === 'page');
+        const layout = rawRoutes.find(route => route.kind === 'file' && route.type === 'layout');
+        const allowedRoutes = rawRoutes.filter(route => route.kind === 'dir' || route.type === 'api');
+        for (let rawRoute of allowedRoutes) {
+            prefix = prefix === '/' ? '' : prefix;
+            if (rawRoute.kind === 'dir') {
+                _getApiRoutes(rawRoute.children, routes, prefix + '/' + rawRoute.parentSegment);
+                continue;
+            }
+            if (rawRoute.type === 'api') {
+                if (layout) {
+                    warnings.push({
+                        type: 'api',
+                        msg: getConflictWaring(rawRoute, layout)
+                    });
+                    continue;
+                }
+                if (page) {
+                    warnings.push({
+                        type: 'api',
+                        msg: getConflictWaring(rawRoute, page)
+                    });
+                    continue;
+                }
+                let path = prefix + '/' + rawRoute.segment;
+                if (path === '//') {
+                    path = '/';
+                }
+                routes.push({
+                    path,
+                    api: rawRoute.filepath
+                });
+            }
+        }
+        return routes;
+    };
+    const routes = (0, helpers_1.sortRoutes)(_getApiRoutes(rawRoutes, [], ''));
+    const filterException = (e) => e.type === 'api';
+    return {
+        routes,
+        warnings: warnings.filter(filterException),
+        errors: errors.filter(filterException)
+    };
+});
+exports.getApiRoutes = getApiRoutes;
+const getMiddlewareRoutes = (dirname) => __awaiter(void 0, void 0, void 0, function* () {
+    const { routes: rawRoutes, warnings, errors } = yield (0, exports.getRawRoutesFromDir)(dirname);
+    const _getMiddlewareRoutes = (rawRoutes, routes, segment) => {
+        segment = segment === '/' ? '' : segment;
+        for (const rawRoute of rawRoutes) {
+            if (rawRoute.kind === 'dir') {
+                _getMiddlewareRoutes(rawRoute.children, routes, segment + '/' + rawRoute.parentSegment);
+                continue;
+            }
+            if (rawRoute.type === 'middleware') {
+                let path = segment + '/' + rawRoute.segment;
+                let catchAllOp = '/*';
+                if (path === '//') {
+                    path = '/';
+                }
+                if (path === '/') {
+                    catchAllOp = catchAllOp.slice(1);
+                }
+                routes.push({
+                    path: path + catchAllOp,
+                    middleware: rawRoute.filepath
+                });
+            }
+        }
+        return routes;
+    };
+    const routes = (0, helpers_1.sortRoutes)(_getMiddlewareRoutes(rawRoutes, [], ''));
+    routes.forEach(route => {
+        if (!route.path.startsWith('/')) {
+            route.path = `/${route.path}`;
+        }
+    });
+    const exceptionFilter = (e) => e.type === 'middleware';
+    return {
+        routes,
+        warnings: warnings.filter(exceptionFilter),
+        errors: errors.filter(exceptionFilter)
+    };
+});
+exports.getMiddlewareRoutes = getMiddlewareRoutes;

package/lib/shared/application.d.ts

@@ -0,0 +1,82 @@
+import { IRouter } from './routerTypes';
+import { IStoreManager, IApplication, IAppContext, IApplicationOptions, IRerenderConfig } from './applicationTypes';
+export declare class Application {
+    private _error;
+    private _router;
+    private _appComponent;
+    private _pluginManager;
+    private _context;
+    private _storeManager;
+    constructor(options: IApplicationOptions);
+    get router(): IRouter<any>;
+    get context(): IAppContext;
+    get pluginManager(): import("@shuvi/hook").HookManager<import("./lifecycle").BuiltInRuntimePluginHooks, void, import("@shuvi/runtime").CustomRuntimePluginHooks>;
+    get appComponent(): any;
+    get error(): {
+        $state: import("./applicationTypes").IErrorState;
+        $set: (state: import("@shuvi/redox").State) => void;
+        $modify: (modifier: (state: import("./applicationTypes").IErrorState) => void) => void;
+        $patch: (partState: import("@shuvi/redox").ObjectState) => void;
+        $actions: {
+            setError: (payload?: import("./applicationTypes").IError | undefined) => import("@shuvi/redox").Action<import("./applicationTypes").IError | undefined>;
+        } & {
+            error: (payload?: import("./applicationTypes").IError | undefined) => void;
+            clear: () => void;
+        } & {
+            [X: string]: never;
+            [X: number]: never;
+            [X: symbol]: never;
+        };
+        $views: import("@shuvi/redox").RedoxViews<({
+            getError(): import("./applicationTypes").IError | undefined;
+            hasError(): boolean;
+        } & ThisType<import("./applicationTypes").IErrorState & {
+            $state: import("./applicationTypes").IErrorState;
+        } & import("@shuvi/redox").RedoxViews<{
+            getError(): import("./applicationTypes").IError | undefined;
+            hasError(): boolean;
+        }> & {
+            $dep: {} & {} & {};
+        }>) | undefined>;
+        $createSelector: <TReturn>(selector: import("@shuvi/redox").ISelector<import("@shuvi/redox").Model<"error", import("./applicationTypes").IErrorState, {}, {
+            setError(_state: import("./applicationTypes").IErrorState, error?: import("./applicationTypes").IError | undefined): {
+                error: import("./applicationTypes").IError | undefined;
+            };
+        }, {
+            error(payload?: import("./applicationTypes").IError | undefined): void;
+            clear(): void;
+        }, {
+            getError(): import("./applicationTypes").IError | undefined;
+            hasError(): boolean;
+        }>, TReturn>) => (() => TReturn) & {
+            clearCache: () => void;
+        };
+    } & import("@shuvi/redox").RedoxViews<{
+        getError(): import("./applicationTypes").IError | undefined;
+        hasError(): boolean;
+    } & ThisType<import("./applicationTypes").IErrorState & {
+        $state: import("./applicationTypes").IErrorState;
+    } & import("@shuvi/redox").RedoxViews<{
+        getError(): import("./applicationTypes").IError | undefined;
+        hasError(): boolean;
+    }> & {
+        $dep: {} & {} & {};
+    }>> & {
+        setError: (payload?: import("./applicationTypes").IError | undefined) => import("@shuvi/redox").Action<import("./applicationTypes").IError | undefined>;
+    } & {
+        error: (payload?: import("./applicationTypes").IError | undefined) => void;
+        clear: () => void;
+    } & {
+        [X: string]: never;
+        [X: number]: never;
+        [X: symbol]: never;
+    };
+    init(): Promise<void>;
+    get storeManager(): IStoreManager;
+    updateComponents({ AppComponent }?: IRerenderConfig): Promise<void>;
+    dispose(): Promise<void>;
+    private _initPlugin;
+    private _initAppContext;
+    private _initAppComponent;
+    getPublicAPI(): IApplication;
+}

package/lib/shared/application.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+const lifecycle_1 = require("./lifecycle");
+const lifecycle_2 = require("./lifecycle");
+const redox_1 = require("@shuvi/redox");
+const error_1 = require("./models/error");
+class Application {
+    constructor(options) {
+        this._router = options.router;
+        this._context = {};
+        this._storeManager = (0, redox_1.redox)({ initialState: options.initialState });
+        this._error = this._storeManager.get(error_1.errorModel);
+        this._appComponent = options.AppComponent;
+        this._pluginManager = (0, lifecycle_1.getManager)();
+        (0, lifecycle_2.initPlugins)(this._pluginManager, options.plugins || []);
+    }
+    get router() {
+        return this._router;
+    }
+    get context() {
+        return this._context;
+    }
+    get pluginManager() {
+        return this._pluginManager;
+    }
+    get appComponent() {
+        return this._appComponent;
+    }
+    get error() {
+        return this._error;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._initPlugin();
+            yield this._initAppContext();
+            yield this._initAppComponent();
+            this._router.init();
+        });
+    }
+    get storeManager() {
+        return this._storeManager;
+    }
+    updateComponents({ AppComponent } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (AppComponent && AppComponent !== this._appComponent) {
+                this._appComponent = AppComponent;
+            }
+            yield this._initAppComponent();
+        });
+    }
+    dispose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._pluginManager.runner.dispose();
+        });
+    }
+    _initPlugin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._pluginManager.runner.init();
+        });
+    }
+    _initAppContext() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._context = (yield this._pluginManager.runner.appContext(this._context));
+        });
+    }
+    _initAppComponent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._appComponent = yield this._pluginManager.runner.appComponent(this._appComponent, this._context);
+        });
+    }
+    getPublicAPI() {
+        return {
+            context: this._context,
+            router: this._router,
+            appComponent: this._appComponent,
+            storeManager: this._storeManager,
+            error: this._error
+        };
+    }
+}
+exports.Application = Application;

package/lib/shared/applicationTypes.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import type { IncomingMessage } from 'http';
+import { IStoreManager } from '@shuvi/redox';
+import { CustomAppContext } from '@shuvi/runtime';
+import { IRouter } from './routerTypes';
+import { IPluginList } from './lifecycle';
+export declare type IRequest = IncomingMessage & {
+    [x: string]: any;
+};
+export interface IAppContext extends CustomAppContext {
+    [x: string]: unknown;
+}
+export declare type IRerenderConfig = {
+    AppComponent?: any;
+};
+export type { IStoreManager };
+export interface IError {
+    code?: number;
+    message?: string;
+}
+export interface IErrorState {
+    error?: IError;
+}
+export declare type IAppState = {
+    error?: IErrorState;
+};
+export interface IErrorManager {
+    getError: IError | undefined;
+    error: (err: IError) => void;
+    clear: () => void;
+    hasError: boolean;
+}
+export interface IApplication {
+    readonly context: IAppContext;
+    readonly router: IRouter;
+    readonly appComponent: any;
+    readonly error: IErrorManager;
+    readonly storeManager: IStoreManager;
+}
+export interface IApplicationOptions {
+    router: IRouter;
+    AppComponent: any;
+    initialState?: IAppState;
+    plugins?: IPluginList;
+}

package/lib/shared/applicationTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/shared/helper/getAppData.d.ts

@@ -0,0 +1,20 @@
+/// <reference lib="dom" />
+export declare type IData = {
+    [k: string]: string | number | boolean | undefined | null;
+};
+export declare type IAppData<Data = {}, appState = any> = {
+    ssr: boolean;
+    runtimeConfig?: Record<string, string>;
+    pageData?: {
+        [key: string]: any;
+    };
+    loadersData?: {
+        [x: string]: any;
+    };
+    appState?: appState;
+    filesByRoutId: Record<string, string[]>;
+    publicPath: string;
+} & {
+    [K in keyof Data]: Data[K];
+};
+export declare function getAppData(): IAppData;

package/lib/shared/helper/getAppData.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppData = void 0;
+/// <reference lib="dom" />
+const constants_1 = require("@shuvi/shared/lib/constants");
+let appData = null;
+function getAppData() {
+    if (appData) {
+        return appData;
+    }
+    if (typeof window === 'undefined') {
+        return {
+            ssr: false,
+            filesByRoutId: {},
+            publicPath: ''
+        };
+    }
+    const el = document.getElementById(constants_1.CLIENT_APPDATA_ID);
+    if (!el || !el.textContent) {
+        return {
+            ssr: false,
+            pageData: {},
+            loadersData: {},
+            filesByRoutId: {},
+            publicPath: ''
+        };
+    }
+    return JSON.parse(el.textContent);
+}
+exports.getAppData = getAppData;

package/lib/shared/helper/getFilesOfRoute.d.ts

@@ -0,0 +1,10 @@
+import type { IRouter, PathRecord } from '../router';
+export declare type RouteFile = {
+    id: string;
+    url: string;
+};
+export declare type RouteFiles = {
+    js: RouteFile[];
+    css: RouteFile[];
+};
+export declare function getFilesOfRoute(router: IRouter, to: PathRecord): RouteFiles;

package/lib/shared/helper/getFilesOfRoute.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilesOfRoute = void 0;
+const getAppData_1 = require("./getAppData");
+const getPublicPath_1 = require("./getPublicPath");
+function getFilesOfRoute(router, to) {
+    const { filesByRoutId } = (0, getAppData_1.getAppData)();
+    const publicPath = (0, getPublicPath_1.getPublicPath)();
+    const js = [];
+    const css = [];
+    const targetRoute = router.match(to);
+    targetRoute.forEach(({ route: { id } }) => {
+        if (!filesByRoutId[id]) {
+            return;
+        }
+        filesByRoutId[id].map(path => {
+            const file = {
+                url: `${publicPath}${path}`,
+                id
+            };
+            if (path.endsWith('.js')) {
+                js.push(file);
+            }
+            else if (path.endsWith('.css')) {
+                css.push(file);
+            }
+        });
+    });
+    return {
+        js,
+        css
+    };
+}
+exports.getFilesOfRoute = getFilesOfRoute;

package/lib/shared/helper/getPageData.d.ts

@@ -0,0 +1 @@
+export declare function getPageData<T = unknown>(key: string, defaultValue?: T): any;

package/lib/shared/helper/getPageData.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageData = void 0;
+const getAppData_1 = require("./getAppData");
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function getPageData(key, defaultValue) {
+    if (typeof window === 'undefined') {
+        console.warn('"getPageData" should only be called on client-side');
+        return defaultValue;
+    }
+    const { pageData = {} } = (0, getAppData_1.getAppData)();
+    if (!hasOwnProperty.call(pageData, key)) {
+        return defaultValue;
+    }
+    return pageData[key];
+}
+exports.getPageData = getPageData;

package/lib/shared/helper/getPublicPath.d.ts

@@ -0,0 +1 @@
+export declare function getPublicPath(): string;

package/lib/shared/helper/getPublicPath.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicPath = void 0;
+const constants_1 = require("@shuvi/shared/lib/constants");
+const getAppData_1 = require("./getAppData");
+function getPublicPath() {
+    const { publicPath } = (0, getAppData_1.getAppData)();
+    return window[constants_1.IDENTITY_RUNTIME_PUBLICPATH] || publicPath;
+}
+exports.getPublicPath = getPublicPath;

package/lib/shared/helper/index.d.ts

@@ -0,0 +1,5 @@
+export { IData, IAppData, getAppData } from './getAppData';
+export { getPageData } from './getPageData';
+export * from './getPublicPath';
+export * from './getFilesOfRoute';
+export * from './router';

package/lib/shared/helper/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageData = exports.getAppData = void 0;
+var getAppData_1 = require("./getAppData");
+Object.defineProperty(exports, "getAppData", { enumerable: true, get: function () { return getAppData_1.getAppData; } });
+var getPageData_1 = require("./getPageData");
+Object.defineProperty(exports, "getPageData", { enumerable: true, get: function () { return getPageData_1.getPageData; } });
+__exportStar(require("./getPublicPath"), exports);
+__exportStar(require("./getFilesOfRoute"), exports);
+__exportStar(require("./router"), exports);

package/lib/shared/helper/router.d.ts

@@ -0,0 +1,4 @@
+import { IRoute, IPageRouteRecord, IRouteMatch } from '../routerTypes';
+import { Loader } from '../loader';
+export declare function runPreload(to: IRoute<IPageRouteRecord>): Promise<void>;
+export declare function getRouteMatchesWithInvalidLoader(to: IRoute<IPageRouteRecord>, from: IRoute<IPageRouteRecord>, loaders: Record<string, Loader>): IRouteMatch<IPageRouteRecord>[];