@shuvi/platform-web 0.0.1-rc.32 → 1.0.0-rc.0

package/esm/shuvi-app/react/view/ReactView.server.jsx

@@ -0,0 +1,109 @@
+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 * as React from 'react';
+import { renderToString } from 'react-dom/server';
+import { getLoaderManager, redirect } from '@shuvi/platform-shared/shared';
+import { SHUVI_ERROR } from '@shuvi/shared/lib/constants';
+import { Router } from '@shuvi/router-react';
+import Loadable, { LoadableContext } from '../loadable';
+import AppContainer from '../AppContainer';
+import { Head } from '../head';
+export class ReactServerView {
+    constructor() {
+        this.renderApp = ({ app, manifest, getAssetPublicUrl }) => __awaiter(this, void 0, void 0, function* () {
+            yield Loadable.preloadAll();
+            const { storeManager, router, error: appError, appComponent: AppComponent } = app;
+            yield router.ready;
+            // todo: move these into renderer
+            let { pathname, matches, redirected } = router.current;
+            // handler no matches
+            if (!matches.length) {
+                appError.error(SHUVI_ERROR.PAGE_NOT_FOUND);
+            }
+            if (redirected) {
+                return redirect(pathname);
+            }
+            // todo: move loader into app, avoid using global module
+            const loaderManager = getLoaderManager();
+            const loadersData = yield loaderManager.getAllData();
+            const loadableModules = [];
+            let htmlContent;
+            let head;
+            const RootApp = (<Router static router={router}>
+        <AppContainer app={app}>
+          <LoadableContext.Provider value={moduleName => loadableModules.push(moduleName)}>
+            <AppComponent />
+          </LoadableContext.Provider>
+        </AppContainer>
+      </Router>);
+            try {
+                htmlContent = renderToString(RootApp);
+            }
+            finally {
+                loaderManager.clearAllData();
+                head = Head.rewind() || [];
+            }
+            const { loadble } = manifest;
+            const dynamicImportIdSet = new Set();
+            const dynamicImportChunkSet = new Set();
+            for (const mod of loadableModules) {
+                const manifestItem = loadble[mod];
+                if (manifestItem) {
+                    manifestItem.files.forEach(file => {
+                        dynamicImportChunkSet.add(file);
+                    });
+                    manifestItem.children.forEach(item => {
+                        dynamicImportIdSet.add(item.id);
+                    });
+                }
+            }
+            const preloadDynamicChunks = [];
+            const styles = [];
+            for (const file of dynamicImportChunkSet) {
+                if (/\.js$/.test(file)) {
+                    preloadDynamicChunks.push({
+                        tagName: 'link',
+                        attrs: {
+                            rel: 'preload',
+                            href: getAssetPublicUrl(file),
+                            as: 'script'
+                        }
+                    });
+                }
+                else if (/\.css$/.test(file)) {
+                    styles.push({
+                        tagName: 'link',
+                        attrs: {
+                            rel: 'stylesheet',
+                            href: getAssetPublicUrl(file)
+                        }
+                    });
+                }
+            }
+            const appData = {
+                dynamicIds: [...dynamicImportIdSet],
+                loadersData
+            };
+            if (dynamicImportIdSet.size) {
+                appData.dynamicIds = Array.from(dynamicImportIdSet);
+            }
+            appData.appState = storeManager.getState();
+            return {
+                appData,
+                content: htmlContent,
+                htmlAttrs: {},
+                headBeginTags: [...head, ...preloadDynamicChunks],
+                headEndTags: [...styles],
+                bodyBeginTags: [],
+                bodyEndTags: []
+            };
+        });
+    }
+}

package/esm/shuvi-app/react/view/clientView.d.ts

@@ -0,0 +1,3 @@
+import { ReactClientView } from './ReactView.client';
+declare const _default: ReactClientView;
+export default _default;

package/esm/shuvi-app/react/view/clientView.js

@@ -0,0 +1,2 @@
+import { ReactClientView } from './ReactView.client';
+export default new ReactClientView();

package/esm/shuvi-app/react/view/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: typeof import("./clientView") | typeof import("./serverView");
+export = _exports;

package/esm/shuvi-app/react/view/index.js

@@ -0,0 +1,7 @@
+"use strict";
+if (__BROWSER__) {
+    module.exports = require('./clientView');
+}
+else {
+    module.exports = require('./serverView');
+}

package/esm/shuvi-app/react/view/render-action.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+declare type RenderActionParam = {
+    ssr?: boolean;
+    isInitialRender?: boolean;
+    root?: ReactNode;
+    callback?: () => unknown;
+    appContainer?: Element | Document;
+};
+declare let renderAction: (options: RenderActionParam) => void;
+export { renderAction };

package/esm/shuvi-app/react/view/render-action.js

@@ -0,0 +1,29 @@
+let renderAction;
+if (process.env.__SHUVI__AFTER__REACT__18__) {
+    const { createRoot, hydrateRoot } = require('react-dom/client');
+    let renderRoot;
+    renderAction = ({ ssr, isInitialRender, root, callback, appContainer }) => {
+        if (ssr && isInitialRender) {
+            renderRoot = hydrateRoot(appContainer, root);
+            callback === null || callback === void 0 ? void 0 : callback();
+        }
+        else {
+            if (!renderRoot) {
+                renderRoot = createRoot(appContainer);
+            }
+            renderRoot.render(root);
+        }
+    };
+}
+else {
+    const { hydrate, render } = require('react-dom');
+    renderAction = ({ ssr, isInitialRender, root, callback, appContainer }) => {
+        if (ssr && isInitialRender) {
+            hydrate(root, appContainer, callback);
+        }
+        else {
+            render(root, appContainer);
+        }
+    };
+}
+export { renderAction };

package/esm/shuvi-app/react/view/serverView.d.ts

@@ -0,0 +1,3 @@
+import { ReactServerView } from './ReactView.server';
+declare const _default: ReactServerView;
+export default _default;

package/esm/shuvi-app/react/view/serverView.js

@@ -0,0 +1,2 @@
+import { ReactServerView } from './ReactView.server';
+export default new ReactServerView();

package/esm/shuvi-app/react/view/transformRoutes.d.ts

@@ -0,0 +1,2 @@
+import { IPageRouteRecord } from '@shuvi/platform-shared/shared';
+export declare const transformRoutes: (routes: IPageRouteRecord[]) => IPageRouteRecord[];

package/esm/shuvi-app/react/view/transformRoutes.js

@@ -0,0 +1,3 @@
+export const transformRoutes = (routes) => {
+    return routes;
+};

package/esm/shuvi-app/shuvi-runtime-index.d.ts

@@ -0,0 +1,4 @@
+import { IRequestHandlerWithNext } from '@shuvi/service';
+import { IApiRequestHandler } from '../shared';
+export declare type MiddlewareHandler = IRequestHandlerWithNext;
+export declare type APIHandler = IApiRequestHandler;

package/esm/shuvi-app/shuvi-runtime-index.js

@@ -0,0 +1,2 @@
+// exported by @shuvi/runtme
+export {};

package/esm/shuvi-app/shuvi-runtime-server.d.ts

@@ -0,0 +1,6 @@
+import { IServerModule as _IServerModule } from '../shared';
+declare type ServerModule = Required<_IServerModule>;
+export declare type GetPageDataFunction = ServerModule['getPageData'];
+export declare type HandlePageRequestFunction = ServerModule['handlePageRequest'];
+export declare type ModifyHtmlFunction = ServerModule['modifyHtml'];
+export {};

package/esm/shuvi-app/shuvi-runtime-server.js

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

package/lib/node/features/custom-server/hooks.d.ts

@@ -0,0 +1,9 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { IAppContext } from '@shuvi/platform-shared/shared';
+import { IHtmlDocument } from '../html-render';
+export declare type IHandlePageRequest = (req: IncomingMessage, res: ServerResponse) => any;
+export declare const extendedHooks: {
+    getPageData: import("@shuvi/hook").AsyncParallelHook<void, IAppContext, Record<string, unknown>>;
+    handlePageRequest: import("@shuvi/hook").SyncWaterfallHook<IHandlePageRequest, void>;
+    modifyHtml: import("@shuvi/hook").AsyncParallelHook<IHtmlDocument, IAppContext, void>;
+};

package/lib/node/features/custom-server/hooks.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendedHooks = void 0;
+const hook_1 = require("@shuvi/hook");
+const getPageData = (0, hook_1.createAsyncParallelHook)();
+const handlePageRequest = (0, hook_1.createSyncWaterfallHook)();
+// todo: change to AsyncSeries
+const modifyHtml = (0, hook_1.createAsyncParallelHook)();
+exports.extendedHooks = {
+    getPageData,
+    handlePageRequest,
+    modifyHtml
+};

package/lib/node/features/custom-server/index.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    core: import("@shuvi/hook").IPluginInstance<{
+        afterInit: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+        afterBuild: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+        afterDestroy: import("@shuvi/hook").AsyncParallelHook<void, void, void>;
+        afterBundlerDone: import("@shuvi/hook").AsyncParallelHook<import("@shuvi/service/lib/core/lifecycleTypes").BundlerDoneExtra, void, void>;
+        afterBundlerTargetDone: import("@shuvi/hook").AsyncParallelHook<import("@shuvi/service/lib/core/lifecycleTypes").BundlerTargetDoneExtra, void, void>;
+        configWebpack: import("@shuvi/hook").AsyncSeriesWaterfallHook<import("@shuvi/service/lib/core/lifecycleTypes").WebpackChainType, import("@shuvi/service/lib/core/lifecycleTypes").ConfigWebpackAssistant>;
+        addExtraTarget: import("@shuvi/hook").AsyncParallelHook<import("@shuvi/service/lib/core/lifecycleTypes").ExtraTargetAssistant, void, import("@shuvi/service/lib/core/lifecycleTypes").TargetChain>;
+        addResource: import("@shuvi/hook").AsyncParallelHook<void, void, import("@shuvi/service/lib/core/lifecycleTypes").Resources | import("@shuvi/service/lib/core/lifecycleTypes").Resources[]>;
+        addRuntimeFile: import("@shuvi/hook").AsyncParallelHook<void, import("@shuvi/service/lib/core/lifecycleTypes").AddRuntimeFileUtils, import("@shuvi/service/lib/project/index").FileOptions<any, any> | import("@shuvi/service/lib/project/index").FileOptions<any, any>[]>;
+        addRuntimeService: import("@shuvi/hook").AsyncParallelHook<void, void, import("@shuvi/service/lib/core/lifecycleTypes").RuntimeService | import("@shuvi/service/lib/core/lifecycleTypes").RuntimeService[]>;
+    } & import("@shuvi/runtime").CustomCorePluginHooks, import("@shuvi/service").IPluginContext>;
+    server: import("@shuvi/hook").IPluginInstance<import("@shuvi/service/lib/server/plugin").BuiltInServerPluginHooks & import("@shuvi/runtime").CustomServerPluginHooks, import("@shuvi/service").IServerPluginContext>;
+    types: string;
+};
+export default _default;

package/lib/node/features/custom-server/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_1 = require("@shuvi/service");
+const file_utils_1 = require("@shuvi/service/lib/project/file-utils");
+const paths_1 = require("../../paths");
+const server_1 = __importDefault(require("./server"));
+const core = (0, service_1.createPlugin)({
+    addRuntimeFile: ({ defineFile }, context) => {
+        const { paths } = context;
+        const serverCandidates = (0, file_utils_1.getUserCustomFileCandidates)(paths.rootDir, 'server', 'noop');
+        const userServerFile = defineFile({
+            name: 'user/server.js',
+            content: () => {
+                return (0, file_utils_1.getFirstModuleExport)((0, file_utils_1.getAllFiles)(serverCandidates), serverCandidates);
+            },
+            dependencies: serverCandidates
+        });
+        return [userServerFile];
+    }
+});
+exports.default = {
+    core,
+    server: server_1.default,
+    types: (0, paths_1.resolvePkgFile)('lib/node/features/custom-server/shuvi-app.d.ts')
+};

package/lib/node/features/custom-server/server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@shuvi/hook").IPluginInstance<import("@shuvi/service/lib/server/plugin").BuiltInServerPluginHooks & import("@shuvi/runtime").CustomServerPluginHooks, import("@shuvi/service").IServerPluginContext>;
+export default _default;

package/lib/node/features/custom-server/server.js

@@ -0,0 +1,32 @@
+"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 });
+const service_1 = require("@shuvi/service");
+const resources_1 = require("@shuvi/service/lib/resources");
+const hooks_1 = require("./hooks");
+exports.default = (0, service_1.createServerPlugin)({
+    setup: ({ addHooks }) => {
+        addHooks(hooks_1.extendedHooks);
+    },
+    getPageData: (appContext, context) => {
+        var _a, _b;
+        return ((_b = (_a = resources_1.server === null || resources_1.server === void 0 ? void 0 : resources_1.server.server) === null || _a === void 0 ? void 0 : _a.getPageData) === null || _b === void 0 ? void 0 : _b.call(_a, appContext, context)) || {};
+    },
+    handlePageRequest: (originalHandlePageRequest, context) => {
+        var _a, _b;
+        return (((_b = (_a = resources_1.server === null || resources_1.server === void 0 ? void 0 : resources_1.server.server) === null || _a === void 0 ? void 0 : _a.handlePageRequest) === null || _b === void 0 ? void 0 : _b.call(_a, originalHandlePageRequest, context)) ||
+            originalHandlePageRequest);
+    },
+    modifyHtml: (document, context, pluginContext) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        yield ((_b = (_a = resources_1.server === null || resources_1.server === void 0 ? void 0 : resources_1.server.server) === null || _a === void 0 ? void 0 : _a.modifyHtml) === null || _b === void 0 ? void 0 : _b.call(_a, document, context, pluginContext));
+    })
+});

package/lib/node/features/custom-server/shuvi-app.d.ts

@@ -0,0 +1,11 @@
+import { extendedHooks } from './hooks';
+declare module '@shuvi/runtime' {
+    interface CustomAppContext {
+        pageData?: any;
+    }
+    interface CustomServerPluginHooks {
+        getPageData: typeof extendedHooks.getPageData;
+        handlePageRequest: typeof extendedHooks.handlePageRequest;
+        modifyHtml: typeof extendedHooks.modifyHtml;
+    }
+}

package/lib/node/features/custom-server/shuvi-app.js

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

package/lib/node/features/filesystem-routes/api/apiRouteHandler.d.ts

@@ -0,0 +1,50 @@
+import { IncomingMessage } from 'http';
+import { IResponse, IRequest } from '@shuvi/service';
+import { IApiRequestHandler, IApiResponse } from '../../../../shared';
+export { IApiRequestHandler };
+export declare function apiRouteHandler(req: IRequest, res: IResponse, resolver: IApiRequestHandler, apiRoutesConfig: any): Promise<void>;
+/**
+ * Parse incoming message like `json` or `urlencoded`
+ * @param req request object
+ */
+export declare function parseBody(req: IRequest, limit: string | number): Promise<any>;
+/**
+ * Parse cookies from `req` header
+ * @param req request object
+ */
+export declare function getCookieParser(req: IncomingMessage): {
+    [key: string]: string;
+};
+/**
+ *
+ * @param res ServerResponse object
+ * @param statusCode `HTTP` status code of response
+ */
+export declare function sendStatusCode<IRes extends IApiResponse>(res: IResponse, statusCode: number): IRes;
+/**
+ *
+ * @param res response object
+ * @param [statusOrUrl] `HTTP` status code of redirect
+ * @param url URL of redirect
+ */
+export declare function redirect<IRes extends IApiResponse>(res: IResponse, statusOrUrl: string | number, url?: string): IRes;
+/**
+ * Send `any` body to response
+ * @param req request object
+ * @param res response object
+ * @param body of response
+ */
+export declare function sendData(req: IRequest, res: IResponse, body: any): void;
+/**
+ * Send `JSON` object
+ * @param res response object
+ * @param jsonBody of data
+ */
+export declare function sendJson(req: IRequest, res: IResponse, jsonBody: any): void;
+/**
+ * Custom error class
+ */
+export declare class ApiError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}

package/lib/node/features/filesystem-routes/api/apiRouteHandler.js

@@ -0,0 +1,237 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.ApiError = exports.sendJson = exports.sendData = exports.redirect = exports.sendStatusCode = exports.getCookieParser = exports.parseBody = exports.apiRouteHandler = void 0;
+const stream_1 = require("stream");
+const querystring = __importStar(require("querystring"));
+const cookie = __importStar(require("cookie"));
+const getRawBody = require('raw-body');
+const contentType = __importStar(require("content-type"));
+function apiRouteHandler(req, res, resolver, apiRoutesConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { bodyParser } = apiRoutesConfig || {};
+            const { pathname, query, params } = req;
+            const apiReq = {
+                pathname,
+                query,
+                params,
+                // Parsing of cookies
+                cookies: getCookieParser(req)
+            };
+            // Parsing of body
+            if (bodyParser && !apiReq.body) {
+                apiReq.body = yield parseBody(req, bodyParser && bodyParser.sizeLimit ? bodyParser.sizeLimit : '1mb');
+            }
+            const apiRes = {
+                status: (statusCode) => sendStatusCode(res, statusCode),
+                send: (data) => sendData(req, res, data),
+                json: (data) => sendJson(req, res, data),
+                redirect: (statusOrUrl, url) => redirect(res, statusOrUrl, url)
+            };
+            let wasPiped = false;
+            if (process.env.NODE_ENV !== 'production') {
+                // listen for pipe event and don't show resolve warning
+                res.once('pipe', () => (wasPiped = true));
+            }
+            // Call API route method
+            yield resolver(Object.assign(req, apiReq), Object.assign(res, apiRes));
+            if (process.env.NODE_ENV !== 'production' &&
+                !(res.finished || res.headersSent) &&
+                !wasPiped) {
+                console.warn(`API resolved without sending a response for ${req.url}, this may result in stalled requests.`);
+            }
+        }
+        catch (err) {
+            throw err;
+        }
+    });
+}
+exports.apiRouteHandler = apiRouteHandler;
+/**
+ * Parse incoming message like `json` or `urlencoded`
+ * @param req request object
+ */
+function parseBody(req, limit) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let contentTypeObj;
+        try {
+            contentTypeObj = contentType.parse(req.headers['content-type'] || 'text/plain');
+        }
+        catch (_a) {
+            contentTypeObj = contentType.parse('text/plain');
+        }
+        const { type, parameters } = contentTypeObj;
+        const encoding = (parameters.charset && parameters.charset.toLowerCase()) || 'utf-8';
+        let buffer;
+        try {
+            buffer = yield getRawBody(req, { encoding, limit });
+        }
+        catch (e) {
+            if (e.type === 'entity.too.large') {
+                throw new ApiError(413, `Body exceeded ${limit} limit`);
+            }
+            else {
+                throw new ApiError(400, 'Invalid body');
+            }
+        }
+        const body = buffer.toString();
+        if (type === 'application/json' || type === 'application/ld+json') {
+            return parseJson(body);
+        }
+        else if (type === 'application/x-www-form-urlencoded') {
+            return querystring.decode(body);
+        }
+        else {
+            return body;
+        }
+    });
+}
+exports.parseBody = parseBody;
+/**
+ * Parse `JSON` and handles invalid `JSON` strings
+ * @param str `JSON` string
+ */
+function parseJson(str) {
+    if (str.length === 0) {
+        // special-case empty json body, as it's a common client-side mistake
+        return {};
+    }
+    try {
+        return JSON.parse(str);
+    }
+    catch (e) {
+        throw new ApiError(400, 'Invalid JSON');
+    }
+}
+/**
+ * Parse cookies from `req` header
+ * @param req request object
+ */
+function getCookieParser(req) {
+    const header = req.headers.cookie;
+    if (!header) {
+        return {};
+    }
+    return cookie.parse(Array.isArray(header) ? header.join(';') : header);
+}
+exports.getCookieParser = getCookieParser;
+/**
+ *
+ * @param res ServerResponse object
+ * @param statusCode `HTTP` status code of response
+ */
+function sendStatusCode(res, statusCode) {
+    res.statusCode = statusCode;
+    return res;
+}
+exports.sendStatusCode = sendStatusCode;
+/**
+ *
+ * @param res response object
+ * @param [statusOrUrl] `HTTP` status code of redirect
+ * @param url URL of redirect
+ */
+function redirect(res, statusOrUrl, url) {
+    if (typeof statusOrUrl === 'string') {
+        url = statusOrUrl;
+        statusOrUrl = 307;
+    }
+    if (typeof statusOrUrl !== 'number' || typeof url !== 'string') {
+        throw new Error(`Invalid redirect arguments. Please use a single argument URL, e.g. res.redirect('/destination') or use a status code and URL, e.g. res.redirect(307, '/destination').`);
+    }
+    res.writeHead(statusOrUrl, { Location: url });
+    res.write('');
+    res.end();
+    return res;
+}
+exports.redirect = redirect;
+/**
+ * Send `any` body to response
+ * @param req request object
+ * @param res response object
+ * @param body of response
+ */
+function sendData(req, res, body) {
+    if (body === null || body === undefined) {
+        res.end();
+        return;
+    }
+    const contentType = res.getHeader('Content-Type');
+    if (body instanceof stream_1.Stream) {
+        if (!contentType) {
+            res.setHeader('Content-Type', 'application/octet-stream');
+        }
+        body.pipe(res);
+        return;
+    }
+    const isJSONLike = ['object', 'number', 'boolean'].includes(typeof body);
+    const stringifiedBody = isJSONLike ? JSON.stringify(body) : body;
+    if (Buffer.isBuffer(body)) {
+        if (!contentType) {
+            res.setHeader('Content-Type', 'application/octet-stream');
+        }
+        res.setHeader('Content-Length', body.length);
+        res.end(body);
+        return;
+    }
+    if (isJSONLike) {
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    }
+    res.setHeader('Content-Length', Buffer.byteLength(stringifiedBody));
+    res.end(stringifiedBody);
+}
+exports.sendData = sendData;
+/**
+ * Send `JSON` object
+ * @param res response object
+ * @param jsonBody of data
+ */
+function sendJson(req, res, jsonBody) {
+    // Set header to application/json
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    // Use send to handle request
+    return sendData(req, res, jsonBody);
+}
+exports.sendJson = sendJson;
+/**
+ * Custom error class
+ */
+class ApiError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+exports.ApiError = ApiError;

package/lib/node/features/filesystem-routes/api/apiRoutes.d.ts

@@ -0,0 +1,7 @@
+import { IApiRouteConfig } from '@shuvi/platform-shared/node';
+export { IApiRouteConfig };
+export declare function serializeApiRoutes(apiRoutes: IApiRouteConfig[]): string;
+export declare function normalizeApiRoutes(apiRoutes: IApiRouteConfig[], option: {
+    apisDir: string;
+}): IApiRouteConfig[];
+export declare const generateRoutesContent: (apiRoutes: IApiRouteConfig[], apisDir: string) => string;