@shuvi/platform-shared 1.0.0-rc.0

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

@@ -0,0 +1,49 @@
+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();
+        }
+    };
+}
+export const getLoaderManager = () => {
+    if (loaderManager) {
+        return loaderManager;
+    }
+    loaderManager = createLoaderManager();
+    return loaderManager;
+};

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

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

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

@@ -0,0 +1,32 @@
+import { defineModel } from '@shuvi/redox';
+import { SHUVI_ERROR } from '@shuvi/shared/lib/constants';
+const DEFAULT_ERRORSTATE = {
+    error: undefined
+};
+export const errorModel = defineModel({
+    name: 'error',
+    state: DEFAULT_ERRORSTATE,
+    reducers: {
+        setError(_state, error) {
+            return Object.assign(Object.assign({}, _state), { error: error });
+        }
+    },
+    actions: {
+        error(payload) {
+            this.setError(payload || SHUVI_ERROR.APP_ERROR);
+        },
+        clear() {
+            if (this.hasError) {
+                this.setError(undefined);
+            }
+        }
+    },
+    views: {
+        getError() {
+            return this.error;
+        },
+        hasError() {
+            return typeof this.error !== 'undefined';
+        }
+    }
+});

package/esm/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 {};

package/esm/shared/response.js

@@ -0,0 +1,126 @@
+const supportIterator = 'Symbol' in global && 'iterator' in Symbol;
+function normalizeName(name) {
+    if (typeof name !== 'string') {
+        name = String(name);
+    }
+    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+        throw new TypeError('Invalid character in header field name: "' + name + '"');
+    }
+    return name.toLowerCase();
+}
+function normalizeValue(value) {
+    if (typeof value !== 'string') {
+        value = String(value);
+    }
+    return value;
+}
+// Build a destructive iterator for the value list
+function iteratorFor(items) {
+    var iterator = {
+        next: function () {
+            var value = items.shift();
+            return { done: value === undefined, value: value };
+        }
+    };
+    if (supportIterator) {
+        iterator[Symbol.iterator] = function () {
+            return iterator;
+        };
+    }
+    return iterator;
+}
+class Headers {
+    constructor(init) {
+        this._map = {};
+        if (init instanceof Headers) {
+            init.forEach((value, name) => {
+                this.append(name, value);
+            });
+        }
+        else if (Array.isArray(init)) {
+            init.forEach(header => this.append(header[0], header[1]));
+        }
+        else if (init) {
+            Object.keys(init).forEach(name => {
+                this.append(name, init[name]);
+            });
+        }
+    }
+    append(name, value) {
+        name = normalizeName(name);
+        value = normalizeValue(value);
+        var oldValue = this._map[name];
+        this._map[name] = oldValue ? oldValue + ', ' + value : value;
+    }
+    delete(name) {
+        delete this._map[normalizeName(name)];
+    }
+    get(name) {
+        name = normalizeName(name);
+        return this.has(name) ? this._map[name] : null;
+    }
+    has(name) {
+        return this._map.hasOwnProperty(normalizeName(name));
+    }
+    set(name, value) {
+        this._map[normalizeName(name)] = normalizeValue(value);
+    }
+    forEach(callback, thisArg) {
+        for (var name in Object.keys(this._map)) {
+            callback.call(thisArg, this._map[name], name, this);
+        }
+    }
+    keys() {
+        const items = [];
+        this.forEach((_value, name) => items.push(name));
+        return iteratorFor(items);
+    }
+    value() {
+        const items = [];
+        this.forEach(value => items.push(value));
+        return iteratorFor(items);
+    }
+    entries() {
+        const items = [];
+        this.forEach((value, name) => items.push([name, value]));
+        return iteratorFor(items);
+    }
+}
+if (supportIterator) {
+    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+}
+class ResponseImpl {
+    constructor(data, type, options = {}) {
+        this.__shuvi_resp_type__ = type;
+        this.data = data;
+        this.status = options.status || 200;
+        this.statusText = options.statusText || '';
+        this.headers = new Headers(options.headers);
+    }
+}
+function createTypeCreator(type) {
+    return (obj) => {
+        return obj && obj.__shuvi_resp_type__ === type;
+    };
+}
+export const isResponse = (obj) => obj && typeof obj.__shuvi_resp_type__ === 'string';
+export const isJson = createTypeCreator('json');
+export const isText = createTypeCreator('text');
+export const isRedirect = createTypeCreator('redirect');
+export function response(data, options) {
+    return new ResponseImpl(data, 'plain', options);
+}
+export function json(data) {
+    return new ResponseImpl(data, 'json');
+}
+export function text(data, options) {
+    return new ResponseImpl(data, 'text', options);
+}
+export function redirect(to, status = 302) {
+    return new ResponseImpl('', 'redirect', {
+        status,
+        headers: {
+            Location: to
+        }
+    });
+}

package/esm/shared/router.d.ts

@@ -0,0 +1 @@
+export { IRouter, PathRecord, matchPathname, rankRouteBranches, parseQuery, createRouter, createBrowserHistory, createHashHistory, createMemoryHistory } from '@shuvi/router';

package/esm/shared/router.js

@@ -0,0 +1 @@
+export { matchPathname, rankRouteBranches, parseQuery, createRouter, createBrowserHistory, createHashHistory, createMemoryHistory } from '@shuvi/router';

package/esm/shared/routerTypes.d.ts

@@ -0,0 +1,28 @@
+import { ParsedQuery, IParams, IRouteRecord } from '@shuvi/router';
+export { IRouter, IRoute, IRouteMatch } from '@shuvi/router';
+export declare type IURLQuery = ParsedQuery;
+export declare type IURLParams = IParams;
+export interface IPageRouteRecord extends IRouteRecord {
+    id: string;
+    component?: any;
+    children?: IPageRouteRecord[];
+    path: string;
+    fullPath?: string;
+    __componentSource__?: never;
+    __componentSourceWithAffix__?: string;
+    __import__?: never;
+    __resolveWeak__?: () => any;
+    [x: string]: any;
+}
+export interface IRawPageRouteRecord extends IRouteRecord {
+    id: string;
+    component?: any;
+    children?: IRawPageRouteRecord[];
+    path: string;
+    fullPath: string;
+    __componentSource__: string;
+    __componentSourceWithAffix__: string;
+    __import__: () => Promise<any>;
+    __resolveWeak__: () => any;
+    [x: string]: any;
+}

package/esm/shared/routerTypes.js

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

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

@@ -0,0 +1,12 @@
+import { IRuntimeConfig } from '@shuvi/service/lib/core';
+/**
+ * getRuntimeConfig function
+ *
+ * @returns runtimeConfig
+ */
+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;

package/esm/shared/shuvi-singleton-runtimeConfig.js

@@ -0,0 +1,19 @@
+let runtimeConfig;
+let publicRuntimeConfig;
+/**
+ * getRuntimeConfig function
+ *
+ * @returns runtimeConfig
+ */
+export function getRuntimeConfig() {
+    return Object.assign(Object.assign({}, (runtimeConfig || {})), (publicRuntimeConfig || {}));
+}
+export function getPublicRuntimeConfig() {
+    return publicRuntimeConfig;
+}
+export function setRuntimeConfig(config) {
+    runtimeConfig = config;
+}
+export function setPublicRuntimeConfig(config) {
+    publicRuntimeConfig = config;
+}

package/esm/shuvi-app/application.d.ts

@@ -0,0 +1,4 @@
+import { Application } from '../shared/application';
+import { IApplicationOptions } from './shared';
+export { Application };
+export default function application(options: IApplicationOptions): Application;

package/esm/shuvi-app/application.js

@@ -0,0 +1,34 @@
+import * as customApp from '@shuvi/app/user/app';
+import { pluginRecord } from '@shuvi/app/core/plugins';
+import { Application } from '../shared/application';
+import { createRuntimePlugin } from './shared';
+export { Application };
+function getPlugins(runtime, pluginRecords) {
+    const plugins = [];
+    const keys = Object.keys(pluginRecords);
+    for (let index = 0; index < keys.length; index++) {
+        const name = keys[index];
+        const plugin = pluginRecords[name];
+        plugins.push([plugin.plugin, plugin.options]);
+    }
+    const pluginConstructor = {};
+    const methods = [
+        'appComponent',
+        'appContext',
+        'init',
+        'dispose'
+    ];
+    for (let index = 0; index < methods.length; index++) {
+        const method = methods[index];
+        if (typeof runtime[method] === 'function') {
+            //@ts-ignore
+            pluginConstructor[method] = runtime[method];
+        }
+    }
+    plugins.push([createRuntimePlugin(pluginConstructor)]);
+    return plugins;
+}
+export default function application(options) {
+    const application = new Application(Object.assign(Object.assign({}, options), { plugins: getPlugins(customApp, pluginRecord) }));
+    return application;
+}

package/esm/shuvi-app/shared.d.ts

@@ -0,0 +1 @@
+export * from '../shared';

package/esm/shuvi-app/shared.js

@@ -0,0 +1 @@
+export * from '../shared';

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

@@ -0,0 +1,14 @@
+/**
+ * export for users
+ *
+ * eg:
+ *  import {} from '@shuvi/runtime/app'
+ *
+ */
+import { IAppModule as _IAppModule } from '../shared/lifecycle';
+declare type AppModule = Required<_IAppModule>;
+export declare type InitFunction = AppModule['init'];
+export declare type AppComponentFunction = AppModule['appComponent'];
+export declare type AppContextFunction = AppModule['appContext'];
+export declare type DisposeFunction = AppModule['dispose'];
+export {};

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * export for users
+ *
+ * eg:
+ *  import {} from '@shuvi/runtime'
+ *
+ */
+export { createRuntimePlugin } from '../shared/lifecycle';
+export { getPageData } from '../shared/helper/getPageData';
+export type { Loader } from '../shared/loader';

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

@@ -0,0 +1,9 @@
+/**
+ * export for users
+ *
+ * eg:
+ *  import {} from '@shuvi/runtime'
+ *
+ */
+export { createRuntimePlugin } from '../shared/lifecycle';
+export { getPageData } from '../shared/helper/getPageData';

package/lib/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './platform';
+export * from './route';

package/lib/node/index.js

@@ -0,0 +1,18 @@
+"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("./platform"), exports);
+__exportStar(require("./route"), exports);

package/lib/node/paths.d.ts

@@ -0,0 +1,3 @@
+export declare const PackageDir: string;
+export declare const resolvePluginFile: (pluginName: string, ...paths: string[]) => string;
+export declare const resolvePkgFile: (...paths: string[]) => string;

package/lib/node/paths.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePkgFile = exports.resolvePluginFile = exports.PackageDir = void 0;
+const path_1 = __importDefault(require("path"));
+exports.PackageDir = path_1.default.resolve(__dirname, '..', '..');
+const resolvePluginFile = (pluginName, ...paths) => path_1.default.join(exports.PackageDir, 'lib', 'node', 'platform', 'plugins', pluginName, ...paths);
+exports.resolvePluginFile = resolvePluginFile;
+const resolvePkgFile = (...paths) => path_1.default.join(exports.PackageDir, ...paths);
+exports.resolvePkgFile = resolvePkgFile;

package/lib/node/platform/index.d.ts

@@ -0,0 +1,16 @@
+export * from './runtimeFiles';
+export declare const SharedPlugins: {
+    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>;
+    types: string;
+}[];

package/lib/node/platform/index.js

@@ -0,0 +1,23 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedPlugins = void 0;
+const main_1 = __importDefault(require("./plugins/main"));
+__exportStar(require("./runtimeFiles"), exports);
+exports.SharedPlugins = [main_1.default];

package/lib/node/platform/plugins/main/hooks.d.ts

@@ -0,0 +1,9 @@
+import { IRuntimeConfig } from '@shuvi/service/lib/core';
+export declare const extendedHooks: {
+    addEntryCode: import("@shuvi/hook").AsyncParallelHook<void, void, string | string[]>;
+    addPolyfill: import("@shuvi/hook").AsyncParallelHook<void, void, string | string[]>;
+    modifyRuntimeConfig: import("@shuvi/hook").AsyncSeriesWaterfallHook<{
+        public: IRuntimeConfig;
+        server: IRuntimeConfig;
+    }, void>;
+};

package/lib/node/platform/plugins/main/hooks.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendedHooks = void 0;
+const hook_1 = require("@shuvi/hook");
+const addEntryCode = (0, hook_1.createAsyncParallelHook)();
+const addPolyfill = (0, hook_1.createAsyncParallelHook)();
+const modifyRuntimeConfig = (0, hook_1.createAsyncSeriesWaterfallHook)();
+exports.extendedHooks = {
+    addEntryCode,
+    addPolyfill,
+    modifyRuntimeConfig
+};

package/lib/node/platform/plugins/main/index.d.ts

@@ -0,0 +1,16 @@
+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>;
+    types: string;
+};
+export default _default;