@shuvi/platform-shared 1.0.0-rc.0

package/lib/shared/helper/router.js

@@ -0,0 +1,68 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRouteMatchesWithInvalidLoader = exports.runPreload = void 0;
+const isEqual_1 = __importDefault(require("@shuvi/utils/lib/isEqual"));
+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);
+    });
+}
+exports.runPreload = runPreload;
+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 (!(0, isEqual_1.default)(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;
+}
+exports.getRouteMatchesWithInvalidLoader = getRouteMatchesWithInvalidLoader;

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

@@ -0,0 +1,28 @@
+"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.createRuntimePlugin = exports.errorModel = void 0;
+__exportStar(require("./helper"), exports);
+__exportStar(require("./routerTypes"), exports);
+__exportStar(require("./router"), exports);
+__exportStar(require("./response"), exports);
+__exportStar(require("./loader"), exports);
+var error_1 = require("./models/error");
+Object.defineProperty(exports, "errorModel", { enumerable: true, get: function () { return error_1.errorModel; } });
+__exportStar(require("./applicationTypes"), exports);
+var lifecycle_1 = require("./lifecycle");
+// fix createRuntimePlugin is not portable end
+Object.defineProperty(exports, "createRuntimePlugin", { enumerable: true, get: function () { return lifecycle_1.createRuntimePlugin; } });

package/lib/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/lib/shared/lifecycle.js

@@ -0,0 +1,45 @@
+"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.initPlugins = exports.createRuntimePlugin = exports.getManager = void 0;
+const hook_1 = require("@shuvi/hook");
+const init = (0, hook_1.createAsyncParallelHook)();
+const appContext = (0, hook_1.createAsyncSeriesWaterfallHook)();
+const appComponent = (0, hook_1.createAsyncSeriesWaterfallHook)();
+const dispose = (0, hook_1.createAsyncParallelHook)();
+const builtinRuntimePluginHooks = {
+    init,
+    appComponent,
+    appContext,
+    dispose
+};
+const getManager = () => (0, hook_1.createHookManager)(builtinRuntimePluginHooks, false);
+exports.getManager = getManager;
+exports.createRuntimePlugin = (0, exports.getManager)().createPlugin;
+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 ((0, hook_1.isPluginInstance)(plugin)) {
+            pluginManager.usePlugin(plugin);
+        }
+        else {
+            pluginManager.usePlugin(plugin(parsedOptions));
+        }
+    }
+});
+exports.initPlugins = initPlugins;

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

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

package/lib/shared/loader/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./loader"), exports);
+__exportStar(require("./loaderManager"), exports);
+__exportStar(require("./types"), exports);

package/lib/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/lib/shared/loader/loader.js

@@ -0,0 +1,122 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoaders = exports.runInParallerAndBail = void 0;
+const invariant_1 = __importDefault(require("@shuvi/utils/lib/invariant"));
+const response_1 = require("../response");
+// todo: add unit tests
+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();
+                    }
+                }
+            }));
+        });
+    });
+}
+exports.runInParallerAndBail = runInParallerAndBail;
+function redirectHelper(to, status = 302) {
+    throw (0, response_1.redirect)(to, status);
+}
+function errorHelper(msg, statusCode = 500) {
+    (0, invariant_1.default)(statusCode >= 400 && statusCode < 600, 'status code should be 4xx and 5xx');
+    throw (0, response_1.response)(msg, { status: statusCode });
+}
+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 = (0, response_1.json)(value);
+                }
+            }
+            catch (error) {
+                if (process.env.NODE_ENV === 'development' && !(0, response_1.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;
+    });
+}
+exports.runLoaders = runLoaders;

package/lib/shared/loader/loaderManager.d.ts

@@ -0,0 +1,16 @@
+declare function createLoaderManager(): {
+    getAllData(): Record<string, any>;
+    getData(id: string): any;
+    setDatas(obj: Record<string, any>): void;
+    subscribe(cb: Function): () => void;
+    clearAllData(): void;
+};
+export declare const getLoaderManager: () => {
+    getAllData(): Record<string, any>;
+    getData(id: string): any;
+    setDatas(obj: Record<string, any>): void;
+    subscribe(cb: Function): () => void;
+    clearAllData(): void;
+};
+export declare type LoaderManager = ReturnType<typeof createLoaderManager>;
+export {};

package/lib/shared/loader/loaderManager.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoaderManager = void 0;
+let loaderManager;
+function createLoaderManager() {
+    const datas = new Map();
+    const subscribers = [];
+    return {
+        getAllData() {
+            let res = {};
+            for (const [id, data] of datas.entries()) {
+                res[id] = data;
+            }
+            return res;
+        },
+        getData(id) {
+            if (!datas.has(id)) {
+                return null;
+            }
+            return datas.get(id);
+        },
+        setDatas(obj) {
+            for (const [id, data] of Object.entries(obj)) {
+                datas.set(id, data);
+            }
+            subscribers.forEach(fn => fn());
+        },
+        // setData(id: string, data: any) {
+        //   datas.set(id, data);
+        //   subscribers.forEach(fn => fn());
+        // },
+        subscribe(cb) {
+            subscribers.push(cb);
+            return () => {
+                const index = subscribers.indexOf(cb);
+                if (index >= 0) {
+                    subscribers.splice(index, 1);
+                }
+            };
+        },
+        clearAllData() {
+            datas.clear();
+        }
+    };
+}
+const getLoaderManager = () => {
+    if (loaderManager) {
+        return loaderManager;
+    }
+    loaderManager = createLoaderManager();
+    return loaderManager;
+};
+exports.getLoaderManager = getLoaderManager;

package/lib/shared/loader/types.d.ts

@@ -0,0 +1,73 @@
+import { IURLQuery, IURLParams } from '../routerTypes';
+import { IAppContext, IRequest } from '../applicationTypes';
+import { Response } from '../response';
+export interface LoaderContextOptions {
+    isServer: boolean;
+    req?: IRequest;
+    query: IURLQuery;
+    getAppContext: () => IAppContext;
+}
+export declare type RedirectFunction = (to: string, status?: number) => any;
+export interface ErrorFunction {
+    (): any;
+    (msg: string): any;
+    (msg: string, statusCode?: number): any;
+}
+/**
+ * route component getInitialProps params `context`
+ */
+export interface IRouteLoaderContext {
+    /**
+     * is running on server, if server is true, client will be false
+     */
+    isServer: boolean;
+    /**
+     * current url path
+     */
+    pathname: string;
+    /**
+     * the query string of current url
+     *
+     * eg. url /x?name=xx
+     * ```ts
+     * {name:xx}
+     * ```
+     */
+    query: IURLQuery;
+    /**
+     * the params of current url
+     *
+     * eg. url /x?name=xx path /:lng
+     * ```ts
+     * {lng:x}
+     * ```
+     */
+    params: IURLParams;
+    /**
+     * redirect function
+     *
+     * ```ts
+     * redirect('/target')
+     * redirect('/target', 301)
+     * ```
+     */
+    redirect: RedirectFunction;
+    /**
+     * throw error if necessary
+     * ```ts
+     * error('custom error describe', 502)
+     * ```
+     */
+    error: ErrorFunction;
+    /**
+     * server only
+     */
+    req?: IRequest;
+    /**
+     * Application context object, which is accessiable during the entire lifecycle of application
+     */
+    appContext: IAppContext;
+}
+export declare type Loader<T extends {} = {}> = (loaderContenxt: IRouteLoaderContext) => Promise<T | void | undefined> | T | void | undefined;
+export declare type NormalizedLoader = (loaderContenxt: IRouteLoaderContext) => Promise<Response | undefined>;
+export declare type LoaderDataRecord = Record<string, any>;

package/lib/shared/loader/types.js

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

package/lib/shared/models/error.d.ts

@@ -0,0 +1,13 @@
+import { IErrorState, IError } from '../applicationTypes';
+export declare const errorModel: import("@shuvi/redox").Model<"error", IErrorState, {}, {
+    setError(_state: IErrorState, error?: IError): {
+        error: IError | undefined;
+    };
+}, {
+    error(payload?: IError): void;
+    clear(): void;
+}, {
+    getError(): IError | undefined;
+    hasError(): boolean;
+}>;
+export declare type ErrorModel = typeof errorModel;

package/lib/shared/models/error.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorModel = void 0;
+const redox_1 = require("@shuvi/redox");
+const constants_1 = require("@shuvi/shared/lib/constants");
+const DEFAULT_ERRORSTATE = {
+    error: undefined
+};
+exports.errorModel = (0, redox_1.defineModel)({
+    name: 'error',
+    state: DEFAULT_ERRORSTATE,
+    reducers: {
+        setError(_state, error) {
+            return Object.assign(Object.assign({}, _state), { error: error });
+        }
+    },
+    actions: {
+        error(payload) {
+            this.setError(payload || constants_1.SHUVI_ERROR.APP_ERROR);
+        },
+        clear() {
+            if (this.hasError) {
+                this.setError(undefined);
+            }
+        }
+    },
+    views: {
+        getError() {
+            return this.error;
+        },
+        hasError() {
+            return typeof this.error !== 'undefined';
+        }
+    }
+});

package/lib/shared/response.d.ts

@@ -0,0 +1,51 @@
+declare type HeaderRecord = Record<string, string>;
+declare type HeaderArray = [string, string][];
+export interface ResponseOptions {
+    status?: number;
+    statusText?: string;
+    headers?: HeaderRecord;
+}
+declare class Headers {
+    private _map;
+    constructor(init?: HeaderRecord | HeaderArray);
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    forEach(callback: (value: string, name: string, t: this) => void, thisArg?: any): void;
+    keys(): {
+        next: () => {
+            done: boolean;
+            value: any;
+        };
+    };
+    value(): {
+        next: () => {
+            done: boolean;
+            value: any;
+        };
+    };
+    entries(): {
+        next: () => {
+            done: boolean;
+            value: any;
+        };
+    };
+}
+export declare type ResponseType = 'text' | 'json' | 'redirect' | 'plain';
+export interface Response {
+    readonly data: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+}
+export declare const isResponse: (obj: any) => obj is Response;
+export declare const isJson: (obj: any) => obj is Response;
+export declare const isText: (obj: any) => obj is Response;
+export declare const isRedirect: (obj: any) => obj is Response;
+export declare function response(data: any, options?: ResponseOptions): Response;
+export declare function json(data: any): Response;
+export declare function text(data: string, options?: ResponseOptions): Response;
+export declare function redirect(to: string, status?: number): Response;
+export {};