@shuvi/platform-shared 1.0.0-rc.0

package/esm/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/esm/shared/application.js

@@ -0,0 +1,87 @@
+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());
+    });
+};
+import { getManager } from './lifecycle';
+import { initPlugins } from './lifecycle';
+import { redox } from '@shuvi/redox';
+import { errorModel } from './models/error';
+export class Application {
+    constructor(options) {
+        this._router = options.router;
+        this._context = {};
+        this._storeManager = redox({ initialState: options.initialState });
+        this._error = this._storeManager.get(errorModel);
+        this._appComponent = options.AppComponent;
+        this._pluginManager = getManager();
+        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
+        };
+    }
+}

package/esm/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/esm/shared/applicationTypes.js

@@ -0,0 +1 @@
+export {};

package/esm/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/esm/shared/helper/getAppData.js

@@ -0,0 +1,26 @@
+/// <reference lib="dom" />
+import { CLIENT_APPDATA_ID } from '@shuvi/shared/lib/constants';
+let appData = null;
+export function getAppData() {
+    if (appData) {
+        return appData;
+    }
+    if (typeof window === 'undefined') {
+        return {
+            ssr: false,
+            filesByRoutId: {},
+            publicPath: ''
+        };
+    }
+    const el = document.getElementById(CLIENT_APPDATA_ID);
+    if (!el || !el.textContent) {
+        return {
+            ssr: false,
+            pageData: {},
+            loadersData: {},
+            filesByRoutId: {},
+            publicPath: ''
+        };
+    }
+    return JSON.parse(el.textContent);
+}

package/esm/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/esm/shared/helper/getFilesOfRoute.js

@@ -0,0 +1,30 @@
+import { getAppData } from './getAppData';
+import { getPublicPath } from './getPublicPath';
+export function getFilesOfRoute(router, to) {
+    const { filesByRoutId } = getAppData();
+    const publicPath = 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
+    };
+}

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

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

package/esm/shared/helper/getPageData.js

@@ -0,0 +1,13 @@
+import { getAppData } from './getAppData';
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+export function getPageData(key, defaultValue) {
+    if (typeof window === 'undefined') {
+        console.warn('"getPageData" should only be called on client-side');
+        return defaultValue;
+    }
+    const { pageData = {} } = getAppData();
+    if (!hasOwnProperty.call(pageData, key)) {
+        return defaultValue;
+    }
+    return pageData[key];
+}

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

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

package/esm/shared/helper/getPublicPath.js

@@ -0,0 +1,6 @@
+import { IDENTITY_RUNTIME_PUBLICPATH } from '@shuvi/shared/lib/constants';
+import { getAppData } from './getAppData';
+export function getPublicPath() {
+    const { publicPath } = getAppData();
+    return window[IDENTITY_RUNTIME_PUBLICPATH] || publicPath;
+}

package/esm/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/esm/shared/helper/index.js

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

package/esm/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>[];

package/esm/shared/helper/router.js

@@ -0,0 +1,60 @@
+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());
+    });
+};
+import isEqual from '@shuvi/utils/lib/isEqual';
+export function runPreload(to) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const toMatches = to.matches;
+        const preloadList = [];
+        toMatches.forEach(match => {
+            var _a;
+            const preload = (_a = match.route.component) === null || _a === void 0 ? void 0 : _a.preload;
+            if (preload && typeof preload === 'function') {
+                preloadList.push(preload());
+            }
+        });
+        yield Promise.all(preloadList);
+    });
+}
+export function getRouteMatchesWithInvalidLoader(to, from, loaders) {
+    const toMatches = to.matches;
+    const fromMatches = from.matches;
+    let changedMatches = [];
+    /**
+     * When a navigation is triggered, loaders should run in the following situation:
+     * 1. If a route changed (new route or same dynamic route but different params), its loader and all its children's loaders should run.
+     * 2. Last nested route's loader should always run.
+     */
+    for (let i = 0; i < toMatches.length; i++) {
+        const currentToMatch = toMatches[i];
+        const currentFromMatch = fromMatches[i];
+        // new route
+        if (currentToMatch.route.id !== (currentFromMatch === null || currentFromMatch === void 0 ? void 0 : currentFromMatch.route.id)) {
+            changedMatches.push(...toMatches.slice(i));
+            break;
+            // same route but different params
+        }
+        else if (!isEqual(currentToMatch.params, currentFromMatch === null || currentFromMatch === void 0 ? void 0 : currentFromMatch.params)) {
+            changedMatches.push(...toMatches.slice(i));
+            break;
+        }
+        // last nested route (last match)
+        if (i === toMatches.length - 1) {
+            changedMatches.push(currentToMatch);
+        }
+    }
+    const targets = [];
+    changedMatches.forEach(match => {
+        const id = match.route.id;
+        if (loaders[id] && typeof loaders[id] === 'function') {
+            targets.push(match);
+        }
+    });
+    return targets;
+}

package/esm/shared/index.d.ts

@@ -0,0 +1,9 @@
+export * from './helper';
+export * from './routerTypes';
+export * from './router';
+export * from './response';
+export * from './loader';
+export { errorModel } from './models/error';
+export * from './applicationTypes';
+export type { Application } from './application';
+export { IAppModule, IPluginInstance, BuiltInRuntimePluginHooks, CustomRuntimePluginHooks, RuntimePluginHooks, createRuntimePlugin, RuntimePluginInstance } from './lifecycle';

package/esm/shared/index.js

@@ -0,0 +1,10 @@
+export * from './helper';
+export * from './routerTypes';
+export * from './router';
+export * from './response';
+export * from './loader';
+export { errorModel } from './models/error';
+export * from './applicationTypes';
+export { 
+// fix createRuntimePlugin is not portable end
+createRuntimePlugin } from './lifecycle';

package/esm/shared/lifecycle.d.ts

@@ -0,0 +1,46 @@
+import { IPluginInstance, IPluginHandlers, HookMap } from '@shuvi/hook';
+import { CustomRuntimePluginHooks } from '@shuvi/runtime';
+import { IAppContext } from './applicationTypes';
+export declare type AppComponent = unknown;
+declare const init: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+declare const appContext: import("@shuvi/hook").AsyncSeriesWaterfallHook<IAppContext, void>;
+declare const appComponent: import("@shuvi/hook").AsyncSeriesWaterfallHook<unknown, IAppContext>;
+declare const dispose: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+export interface BuiltInRuntimePluginHooks extends HookMap {
+    init: typeof init;
+    appComponent: typeof appComponent;
+    appContext: typeof appContext;
+    dispose: typeof dispose;
+}
+export interface RuntimePluginHooks extends BuiltInRuntimePluginHooks, CustomRuntimePluginHooks {
+}
+export declare const getManager: () => import("@shuvi/hook").HookManager<BuiltInRuntimePluginHooks, void, CustomRuntimePluginHooks>;
+export declare const createRuntimePlugin: (pluginHandlers: Partial<import("@shuvi/hook").IPluginHandlersFullMap<BuiltInRuntimePluginHooks & CustomRuntimePluginHooks, void>> & {
+    setup?: import("@shuvi/hook").Setup<CustomRuntimePluginHooks> | undefined;
+}, options?: import("@shuvi/hook").PluginOptions | undefined) => IPluginInstance<BuiltInRuntimePluginHooks & CustomRuntimePluginHooks, void>;
+export type { IPluginInstance, CustomRuntimePluginHooks };
+export declare type PluginManager = ReturnType<typeof getManager>;
+export declare type RuntimePluginInstance = IPluginInstance<RuntimePluginHooks, void>;
+export declare type IRuntimePluginConstructor = IPluginHandlers<RuntimePluginHooks, void>;
+export declare type IAppModule = {
+    init?: IRuntimePluginConstructor['init'];
+    appContext?: IRuntimePluginConstructor['appContext'];
+    appComponent?: IRuntimePluginConstructor['appComponent'];
+    dispose?: IRuntimePluginConstructor['dispose'];
+};
+declare type SerializedPluginOptions = string;
+export declare type IRuntimePluginOptions = Record<string, unknown>;
+export declare type IRuntimePluginWithOptions = (...params: any[]) => RuntimePluginInstance;
+export declare type IRuntimePlugin = RuntimePluginInstance | IRuntimePluginWithOptions;
+export declare type IPluginModule = {
+    plugin: IRuntimePlugin;
+    pluginOptions: IRuntimePluginOptions;
+};
+export declare type IPluginRecord = {
+    [name: string]: {
+        plugin: IRuntimePlugin;
+        options: SerializedPluginOptions;
+    };
+};
+export declare type IPluginList = [IRuntimePlugin, SerializedPluginOptions?][];
+export declare const initPlugins: (pluginManager: PluginManager, plugins: IPluginList) => Promise<void>;

package/esm/shared/lifecycle.js

@@ -0,0 +1,40 @@
+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());
+    });
+};
+import { createAsyncParallelHook, createAsyncSeriesWaterfallHook, createHookManager, isPluginInstance } from '@shuvi/hook';
+const init = createAsyncParallelHook();
+const appContext = createAsyncSeriesWaterfallHook();
+const appComponent = createAsyncSeriesWaterfallHook();
+const dispose = createAsyncParallelHook();
+const builtinRuntimePluginHooks = {
+    init,
+    appComponent,
+    appContext,
+    dispose
+};
+export const getManager = () => createHookManager(builtinRuntimePluginHooks, false);
+export const { createPlugin: createRuntimePlugin } = getManager();
+export const initPlugins = (pluginManager, plugins) => __awaiter(void 0, void 0, void 0, function* () {
+    // clear plugin at development mode every time
+    if (process.env.NODE_ENV === 'development') {
+        pluginManager.clear();
+    }
+    for (const [plugin, options] of plugins) {
+        let parsedOptions;
+        if (options) {
+            parsedOptions = JSON.parse(options);
+        }
+        if (isPluginInstance(plugin)) {
+            pluginManager.usePlugin(plugin);
+        }
+        else {
+            pluginManager.usePlugin(plugin(parsedOptions));
+        }
+    }
+});

package/esm/shared/loader/index.d.ts

@@ -0,0 +1,3 @@
+export * from './loader';
+export * from './loaderManager';
+export * from './types';

package/esm/shared/loader/index.js

@@ -0,0 +1,3 @@
+export * from './loader';
+export * from './loaderManager';
+export * from './types';

package/esm/shared/loader/loader.d.ts

@@ -0,0 +1,9 @@
+import { IRouteMatch, IPageRouteRecord } from '../routerTypes';
+import { Loader, LoaderContextOptions, LoaderDataRecord } from './types';
+interface Result<T> {
+    error?: unknown;
+    result?: T;
+}
+export declare function runInParallerAndBail<T>(fns: Array<() => Promise<T> | T>): Promise<Result<T>[]>;
+export declare function runLoaders(matches: IRouteMatch<IPageRouteRecord>[], loadersByRouteId: Record<string, Loader>, { isServer, query, req, getAppContext }: LoaderContextOptions): Promise<LoaderDataRecord>;
+export {};

package/esm/shared/loader/loader.js

@@ -0,0 +1,114 @@
+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());
+    });
+};
+import invariant from '@shuvi/utils/lib/invariant';
+import { json as createJson, redirect as createRedirect, response, isResponse } from '../response';
+// todo: add unit tests
+export function runInParallerAndBail(fns) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(resolve => {
+            const resultList = [];
+            let total = fns.length;
+            let finishedNum = 0;
+            let finished = new Map();
+            let abort = false;
+            const doResolve = () => {
+                abort = true;
+                resolve(resultList.slice());
+            };
+            const isAllFinishedBefore = (targetIndex) => {
+                for (let i = 0; i < targetIndex; i++) {
+                    if (!finished.has(i)) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+            // call loaders in parallel
+            fns.map((fn, index) => __awaiter(this, void 0, void 0, function* () {
+                let result;
+                let error;
+                try {
+                    result = yield fn();
+                }
+                catch (err) {
+                    error = err;
+                }
+                if (abort)
+                    return;
+                resultList[index] = {
+                    error,
+                    result
+                };
+                finishedNum += 1;
+                finished.set(index, true);
+                if (finishedNum === total) {
+                    doResolve();
+                }
+                else if (finishedNum === index + 1 && isAllFinishedBefore(index)) {
+                    if (error) {
+                        // we can bail
+                        doResolve();
+                    }
+                }
+            }));
+        });
+    });
+}
+function redirectHelper(to, status = 302) {
+    throw createRedirect(to, status);
+}
+function errorHelper(msg, statusCode = 500) {
+    invariant(statusCode >= 400 && statusCode < 600, 'status code should be 4xx and 5xx');
+    throw response(msg, { status: statusCode });
+}
+export function runLoaders(matches, loadersByRouteId, { isServer, query, req, getAppContext }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!matches.length) {
+            return [];
+        }
+        const appContext = getAppContext();
+        const createLoader = (match) => () => __awaiter(this, void 0, void 0, function* () {
+            const loaderFn = loadersByRouteId[match.route.id];
+            let res;
+            try {
+                const value = yield loaderFn(Object.assign({ isServer, pathname: match.pathname, params: match.params, query: query, redirect: redirectHelper, error: errorHelper, appContext }, (req ? { req } : {})));
+                if (value) {
+                    res = createJson(value);
+                }
+            }
+            catch (error) {
+                if (process.env.NODE_ENV === 'development' && !isResponse(error)) {
+                    console.error(`loader function error of route "${match.route.path}"`);
+                    console.error(error);
+                }
+                throw error;
+            }
+            return res;
+        });
+        // call loaders in parallel
+        const resultList = yield runInParallerAndBail(matches.map(createLoader));
+        const loaderDatas = {};
+        for (let index = 0; index < resultList.length; index++) {
+            const item = resultList[index];
+            if (item.error) {
+                throw item.error;
+            }
+            const routeId = matches[index].route.id;
+            if (item.result) {
+                loaderDatas[routeId] = item.result.data;
+            }
+            else {
+                // allow return undefined
+                loaderDatas[routeId] = undefined;
+            }
+        }
+        return loaderDatas;
+    });
+}