@shuvi/platform-shared 1.0.0-rc.2 → 1.0.0-rc.20

package/esm/shared/application.d.ts

@@ -1,82 +1,31 @@
-import { IRouter } from './routerTypes';
-import { IStoreManager, IApplication, IAppContext, IApplicationOptions, IRerenderConfig } from './applicationTypes';
-export declare class Application {
-    private _error;
+import { IRouter, IPageRouteRecord } from './routerTypes';
+import { RedoxStore, Application, IAppContext, ApplicationOptions, IRerenderConfig, IError } from './applicationTypes';
+export declare class ApplicationImpl<Config extends {} = {}> {
     private _router;
     private _appComponent;
     private _pluginManager;
     private _context;
-    private _storeManager;
-    constructor(options: IApplicationOptions);
-    get router(): IRouter<any>;
+    private _config;
+    private _store;
+    private _error;
+    private _loader;
+    constructor(options: ApplicationOptions<Config>);
+    get router(): IRouter<IPageRouteRecord>;
+    get config(): Config;
     get context(): IAppContext;
-    get pluginManager(): import("@shuvi/hook").HookManager<import("./lifecycle").BuiltInRuntimePluginHooks, void, import("@shuvi/runtime").CustomRuntimePluginHooks>;
+    get pluginManager(): import("@shuvi/hook").HookManager<import("./runtimPlugin").RuntimePluginHooks, void>;
     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;
-    };
+    get error(): IError | undefined;
+    setError(err: IError): void;
+    clearError(): void;
+    getLoadersData(): Record<string, any>;
+    setLoadersData(datas: Record<string, any>): void;
     init(): Promise<void>;
-    get storeManager(): IStoreManager;
+    get store(): RedoxStore;
     updateComponents({ AppComponent }?: IRerenderConfig): Promise<void>;
     dispose(): Promise<void>;
     private _initPlugin;
     private _initAppContext;
     private _initAppComponent;
-    getPublicAPI(): IApplication;
+    getPublicAPI(): Application<Config>;
 }

package/esm/shared/application.js

@@ -7,16 +7,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { getManager } from './lifecycle';
-import { initPlugins } from './lifecycle';
+import { getManager } from './runtimPlugin';
+import { initPlugins } from './runtimPlugin';
 import { redox } from '@shuvi/redox';
 import { errorModel } from './models/error';
-export class Application {
+import { loaderModel } from './models/loader';
+export class ApplicationImpl {
     constructor(options) {
+        this._config = options.config;
         this._router = options.router;
         this._context = {};
-        this._storeManager = redox({ initialState: options.initialState });
-        this._error = this._storeManager.get(errorModel);
+        this._store = redox({ initialState: options.initialState });
+        this._error = this._store.getModel(errorModel);
+        this._loader = this._store.getModel(loaderModel);
         this._appComponent = options.AppComponent;
         this._pluginManager = getManager();
         initPlugins(this._pluginManager, options.plugins || []);
@@ -24,6 +27,9 @@ export class Application {
     get router() {
         return this._router;
     }
+    get config() {
+        return this._config;
+    }
     get context() {
         return this._context;
     }
@@ -34,7 +40,19 @@ export class Application {
         return this._appComponent;
     }
     get error() {
-        return this._error;
+        return this._error.errorObject;
+    }
+    setError(err) {
+        this._error.set(err);
+    }
+    clearError() {
+        this._error.clear();
+    }
+    getLoadersData() {
+        return this._loader.getAllData;
+    }
+    setLoadersData(datas) {
+        this._loader.setDatas(datas);
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -44,8 +62,8 @@ export class Application {
             this._router.init();
         });
     }
-    get storeManager() {
-        return this._storeManager;
+    get store() {
+        return this._store;
     }
     updateComponents({ AppComponent } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -67,7 +85,7 @@ export class Application {
     }
     _initAppContext() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._context = (yield this._pluginManager.runner.appContext(this._context));
+            yield this._pluginManager.runner.appContext(this._context);
         });
     }
     _initAppComponent() {
@@ -76,12 +94,38 @@ export class Application {
         });
     }
     getPublicAPI() {
+        const self = this;
         return {
-            context: this._context,
-            router: this._router,
-            appComponent: this._appComponent,
-            storeManager: this._storeManager,
-            error: this._error
+            get config() {
+                return self._config;
+            },
+            get context() {
+                return self._context;
+            },
+            get router() {
+                return self._router;
+            },
+            get appComponent() {
+                return self._appComponent;
+            },
+            get store() {
+                return self._store;
+            },
+            get error() {
+                return self.error;
+            },
+            setError(err) {
+                self.setError(err);
+            },
+            clearError() {
+                self.clearError();
+            },
+            getLoadersData() {
+                return self.getLoadersData();
+            },
+            setLoadersData(datas) {
+                self.setLoadersData(datas);
+            }
         };
     }
 }

package/esm/shared/applicationTypes.d.ts

@@ -1,22 +1,21 @@
-/// <reference types="node" />
-import type { IncomingMessage } from 'http';
-import { IStoreManager } from '@shuvi/redox';
+import { RedoxStore } from '@shuvi/redox';
 import { CustomAppContext } from '@shuvi/runtime';
-import { IRouter } from './routerTypes';
-import { IPluginList } from './lifecycle';
-export declare type IRequest = IncomingMessage & {
-    [x: string]: any;
-};
+import { IRouter, IPageRouteRecord } from './routerTypes';
+import { IPluginList } from './runtimPlugin';
 export interface IAppContext extends CustomAppContext {
     [x: string]: unknown;
 }
 export declare type IRerenderConfig = {
     AppComponent?: any;
 };
-export type { IStoreManager };
+export type { RedoxStore };
+export declare type ErrorSource = 'server';
 export interface IError {
     code?: number;
     message?: string;
+    stack?: string;
+    name?: string;
+    source?: ErrorSource;
 }
 export interface IErrorState {
     error?: IError;
@@ -24,20 +23,20 @@ export interface IErrorState {
 export declare type IAppState = {
     error?: IErrorState;
 };
-export interface IErrorManager {
-    getError: IError | undefined;
-    error: (err: IError) => void;
-    clear: () => void;
-    hasError: boolean;
-}
-export interface IApplication {
+export interface Application<Config extends {} = {}> {
+    readonly config: Config;
     readonly context: IAppContext;
-    readonly router: IRouter;
+    readonly router: IRouter<IPageRouteRecord>;
     readonly appComponent: any;
-    readonly error: IErrorManager;
-    readonly storeManager: IStoreManager;
+    readonly store: RedoxStore;
+    readonly error: IError | undefined;
+    setError(err: IError): void;
+    clearError(): void;
+    getLoadersData(): Record<string, any>;
+    setLoadersData(datas: Record<string, any>): void;
 }
-export interface IApplicationOptions {
+export interface ApplicationOptions<C extends {}> {
+    config: C;
     router: IRouter;
     AppComponent: any;
     initialState?: IAppState;

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

@@ -5,13 +5,10 @@ export declare type IData = {
 export declare type IAppData<Data = {}, appState = any> = {
     ssr: boolean;
     runtimeConfig?: Record<string, string>;
+    appState?: appState;
     pageData?: {
         [key: string]: any;
     };
-    loadersData?: {
-        [x: string]: any;
-    };
-    appState?: appState;
     filesByRoutId: Record<string, string[]>;
     publicPath: string;
 } & {

package/esm/shared/helper/getAppData.js

@@ -17,7 +17,6 @@ export function getAppData() {
         return {
             ssr: false,
             pageData: {},
-            loadersData: {},
             filesByRoutId: {},
             publicPath: ''
         };

package/esm/shared/helper/getPublicPath.js

@@ -1,6 +1,5 @@
-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;
+    return publicPath;
 }

package/esm/shared/index.d.ts

@@ -4,7 +4,8 @@ export * from './router';
 export * from './response';
 export * from './loader';
 export { errorModel } from './models/error';
+export { loaderModel } from './models/loader';
 export * from './applicationTypes';
-export type { Application } from './application';
+export type { ApplicationImpl } from './application';
 export type { IRuntimeConfig } from './runtimeConfigTypes';
-export { IAppModule, IPluginInstance, BuiltInRuntimePluginHooks, CustomRuntimePluginHooks, RuntimePluginHooks, createRuntimePlugin, RuntimePluginInstance } from './lifecycle';
+export { IAppModule, IPluginInstance, BuiltInRuntimePluginHooks, CustomRuntimePluginHooks, RuntimePluginHooks, createRuntimePlugin, createRuntimePluginBefore, createRuntimePluginAfter, RuntimePluginInstance } from './runtimPlugin';

package/esm/shared/index.js

@@ -4,7 +4,6 @@ export * from './router';
 export * from './response';
 export * from './loader';
 export { errorModel } from './models/error';
+export { loaderModel } from './models/loader';
 export * from './applicationTypes';
-export { 
-// fix createRuntimePlugin is not portable end
-createRuntimePlugin } from './lifecycle';
+export { createRuntimePlugin, createRuntimePluginBefore, createRuntimePluginAfter } from './runtimPlugin';

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

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

package/esm/shared/loader/index.js

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

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

@@ -5,5 +5,5 @@ interface Result<T> {
     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 declare function runLoaders(matches: IRouteMatch<IPageRouteRecord>[], loadersByRouteId: Record<string, Loader>, { query, req, getAppContext }: LoaderContextOptions): Promise<LoaderDataRecord>;
 export {};

package/esm/shared/loader/loader.js

@@ -68,25 +68,30 @@ 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 }) {
+export function runLoaders(matches, loadersByRouteId, { query, req, getAppContext }) {
     return __awaiter(this, void 0, void 0, function* () {
+        const loaderDatas = {};
         if (!matches.length) {
-            return [];
+            return loaderDatas;
         }
         const appContext = getAppContext();
         const createLoader = (match) => () => __awaiter(this, void 0, void 0, function* () {
             const loaderFn = loadersByRouteId[match.route.id];
+            if (typeof loaderFn !== 'function') {
+                return;
+            }
             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);
+                const value = yield loaderFn(Object.assign({ pathname: match.pathname, params: match.params, query: query, redirect: redirectHelper, error: errorHelper, appContext }, (req ? { req } : {})));
+                if (value === undefined) {
+                    throw new Error(`You defined a loader for route "${match.route.path}" but didn't return ` +
+                        `anything from your \`loader\` function. Please return a value or \`null\`.`);
                 }
+                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;
             }
@@ -94,7 +99,6 @@ export function runLoaders(matches, loadersByRouteId, { isServer, query, req, ge
         });
         // 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) {

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

@@ -1,9 +1,9 @@
+import type { ShuviRequest } from '@shuvi/service';
 import { IURLQuery, IURLParams } from '../routerTypes';
-import { IAppContext, IRequest } from '../applicationTypes';
+import { IAppContext } from '../applicationTypes';
 import { Response } from '../response';
 export interface LoaderContextOptions {
-    isServer: boolean;
-    req?: IRequest;
+    req?: ShuviRequest;
     query: IURLQuery;
     getAppContext: () => IAppContext;
 }
@@ -17,10 +17,6 @@ export interface ErrorFunction {
  * 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
      */
@@ -62,12 +58,12 @@ export interface IRouteLoaderContext {
     /**
      * server only
      */
-    req?: IRequest;
+    req?: ShuviRequest;
     /**
      * 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 Loader<T = any> = (loaderContext: IRouteLoaderContext) => Promise<T> | T;
+export declare type NormalizedLoader = (loaderContext: IRouteLoaderContext) => Promise<Response | undefined>;
 export declare type LoaderDataRecord = Record<string, any>;

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

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

package/esm/shared/models/error.js

@@ -12,7 +12,7 @@ export const errorModel = defineModel({
         }
     },
     actions: {
-        error(payload) {
+        set(payload) {
             this.setError(payload || SHUVI_ERROR.APP_ERROR);
         },
         clear() {
@@ -22,7 +22,7 @@ export const errorModel = defineModel({
         }
     },
     views: {
-        getError() {
+        errorObject() {
             return this.error;
         },
         hasError() {

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

@@ -0,0 +1,13 @@
+export interface LoaderState {
+    dataByRouteId: Record<string, any>;
+}
+export declare const loaderModel: import("@shuvi/redox/esm/core/defineModel").DefineModel<"loader", LoaderState, {
+    setDatas(state: LoaderState, newData: Record<string, any>): {
+        dataByRouteId: {
+            [x: string]: any;
+        };
+    };
+}, import("@shuvi/redox/esm/core/defineModel").ActionOptions, {
+    getAllData(): Record<string, any>;
+}, {}>;
+export declare type LoaderModel = typeof loaderModel;

package/esm/shared/models/loader.js

@@ -0,0 +1,24 @@
+import { defineModel } from '@shuvi/redox';
+const initState = {
+    dataByRouteId: {}
+};
+export const loaderModel = defineModel({
+    name: 'loader',
+    state: initState,
+    reducers: {
+        setDatas(state, newData) {
+            return Object.assign(Object.assign({}, state), { dataByRouteId: Object.assign(Object.assign({}, state.dataByRouteId), newData) });
+        }
+        // clearDatas(state) {
+        //   return {
+        //     ...state,
+        //     dataByRouteId: {}
+        //   };
+        // }
+    },
+    views: {
+        getAllData() {
+            return this.dataByRouteId;
+        }
+    }
+});

package/esm/shared/routerTypes.d.ts

@@ -7,18 +7,10 @@ export interface IPageRouteRecord extends IRouteRecord {
     path: string;
     component?: any;
     children?: IPageRouteRecord[];
-    [x: string]: any;
-}
-export interface IRawPageRouteRecord extends IRouteRecord {
-    id: string;
-    path: string;
-    component?: any;
-    children?: IRawPageRouteRecord[];
-    fullPath: string;
-    __componentSource__: string;
-    __componentSourceWithAffix__: string;
-    __import__: () => Promise<any>;
-    __resolveWeak__: () => any;
+    __import__?: () => Promise<any>;
+    __resolveWeak__?: () => string[];
+    __componentSource__?: string;
+    __componentRawRequest__?: string;
     [x: string]: any;
 }
 export interface IPlatformConfig {
@@ -34,7 +26,6 @@ export interface IPageRouteConfig {
     component?: string;
     redirect?: string;
     path: string;
-    fullPath?: string;
 }
 export interface IPageRouteConfigWithId extends IPageRouteConfig {
     id: string;

package/esm/shared/{lifecycle.d.ts → runtimPlugin.d.ts}

@@ -3,7 +3,7 @@ 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 appContext: import("@shuvi/hook").AsyncSeriesHook<IAppContext, void, 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 {
@@ -14,10 +14,8 @@ export interface BuiltInRuntimePluginHooks extends HookMap {
 }
 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 declare const getManager: () => import("@shuvi/hook").HookManager<RuntimePluginHooks, void>;
+export declare const createRuntimePluginBefore: import("@shuvi/shared/lib/plugins").PluginFunc<RuntimePluginHooks, void>, createRuntimePlugin: import("@shuvi/shared/lib/plugins").PluginFunc<RuntimePluginHooks, void>, createRuntimePluginAfter: import("@shuvi/shared/lib/plugins").PluginFunc<RuntimePluginHooks, void>;
 export type { IPluginInstance, CustomRuntimePluginHooks };
 export declare type PluginManager = ReturnType<typeof getManager>;
 export declare type RuntimePluginInstance = IPluginInstance<RuntimePluginHooks, void>;

package/esm/shared/{lifecycle.js → runtimPlugin.js}

@@ -7,9 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createAsyncParallelHook, createAsyncSeriesWaterfallHook, createHookManager, isPluginInstance } from '@shuvi/hook';
+import { createAsyncParallelHook, createAsyncSeriesHook, createAsyncSeriesWaterfallHook, createHookManager, isPluginInstance } from '@shuvi/hook';
+import { createPluginCreator } from '@shuvi/shared/lib/plugins';
 const init = createAsyncParallelHook();
-const appContext = createAsyncSeriesWaterfallHook();
+const appContext = createAsyncSeriesHook();
 const appComponent = createAsyncSeriesWaterfallHook();
 const dispose = createAsyncParallelHook();
 const builtinRuntimePluginHooks = {
@@ -19,7 +20,7 @@ const builtinRuntimePluginHooks = {
     dispose
 };
 export const getManager = () => createHookManager(builtinRuntimePluginHooks, false);
-export const { createPlugin: createRuntimePlugin } = getManager();
+export const { createPluginBefore: createRuntimePluginBefore, createPlugin: createRuntimePlugin, createPluginAfter: createRuntimePluginAfter } = createPluginCreator();
 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') {

package/esm/shared/shuvi-singleton-runtimeConfig.d.ts

@@ -2,11 +2,12 @@ import { IRuntimeConfig } from './runtimeConfigTypes';
 /**
  * getRuntimeConfig function
  *
- * @returns runtimeConfig
+ * @returns serverRuntimeConfig
  */
 export declare function getRuntimeConfig(): {
     [x: string]: string;
 };
-export declare function getPublicRuntimeConfig(): IRuntimeConfig | null;
-export declare function setRuntimeConfig(config: IRuntimeConfig): void;
-export declare function setPublicRuntimeConfig(config: IRuntimeConfig): void;
+export declare function getPublicRuntimeConfig(): IRuntimeConfig | undefined | null;
+export declare function setPublicRuntimeConfig(config: IRuntimeConfig | null): void;
+export declare function getServerRuntimeConfig(): IRuntimeConfig | undefined | null;
+export declare function setServerRuntimeConfig(config: IRuntimeConfig | null): void;