@shuvi/service 0.0.1-pre.1

package/lib/lib/launchEditorMiddleware.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const launch_editor_1 = __importDefault(require("launch-editor"));
+function getSourcePath(source) {
+    // Webpack prefixes certain source paths with this path
+    if (source.startsWith('webpack:///')) {
+        return source.substring(11);
+    }
+    // Make sure library name is filtered out as well
+    if (source.startsWith('webpack://_N_E/')) {
+        return source.substring(15);
+    }
+    if (source.startsWith('webpack://')) {
+        return source.substring(10);
+    }
+    if (source.startsWith('/')) {
+        return source.substring(1);
+    }
+    return source;
+}
+function createLaunchEditorMiddleware(launchEditorEndpoint) {
+    return function launchEditorMiddleware(req, res, next) {
+        if (req.url.startsWith(launchEditorEndpoint)) {
+            const { query } = req;
+            const lineNumber = parseInt(query.lineNumber, 10) || 1;
+            const colNumber = parseInt(query.colNumber, 10) || 1;
+            launch_editor_1.default(getSourcePath(`${query.fileName}:${lineNumber}:${colNumber}`));
+            res.end();
+            return;
+        }
+        else {
+            next();
+        }
+    };
+}
+exports.createLaunchEditorMiddleware = createLaunchEditorMiddleware;

package/lib/lib/matchRoutes.d.ts

@@ -0,0 +1,2 @@
+import { PartialLocation, IRouteMatch, IRouteBaseObject } from '@shuvi/router';
+export declare function matchRoutes<T extends IRouteBaseObject>(routes: T[], location: string | PartialLocation, basename?: string): IRouteMatch<T>[];

package/lib/lib/matchRoutes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const router_1 = require("@shuvi/router");
+// matchRoutes can support any `routes` object
+function matchRoutes(routes, location, basename = '') {
+    return router_1.matchRoutes(routes, location, basename) || [];
+}
+exports.matchRoutes = matchRoutes;

package/lib/lib/onDemandRouteManager.d.ts

@@ -0,0 +1,11 @@
+import { IRequestHandlerWithNext } from '../server';
+import { DevMiddleware } from './devMiddleware';
+import { Api } from '../api/api';
+export declare class OnDemandRouteManager {
+    devMiddleware: DevMiddleware | null;
+    _api: Api;
+    constructor(api: Api);
+    getServerMiddleware(): IRequestHandlerWithNext;
+    ensureRoutes(pathname: string): Promise<void>;
+    private _activateModules;
+}

package/lib/lib/onDemandRouteManager.js

@@ -0,0 +1,69 @@
+"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 });
+const module_replace_plugin_1 = __importDefault(require("@shuvi/toolpack/lib/webpack/plugins/module-replace-plugin"));
+const constants_1 = require("../constants");
+const router_1 = require("@shuvi/router");
+class OnDemandRouteManager {
+    constructor(api) {
+        this.devMiddleware = null;
+        this._api = api;
+    }
+    getServerMiddleware() {
+        return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const pathname = req.pathname;
+            if (!pathname.startsWith(this._api.assetPublicPath)) {
+                return next();
+            }
+            if (!this.devMiddleware) {
+                return next();
+            }
+            const chunkName = pathname.replace(this._api.assetPublicPath, '');
+            const chunkInitiatorModule = this._api.clientManifest.chunkRequest[chunkName];
+            if (!chunkInitiatorModule) {
+                return next();
+            }
+            const task = module_replace_plugin_1.default.restoreModule(chunkInitiatorModule);
+            if (task) {
+                yield this.devMiddleware.invalidate();
+                yield task;
+            }
+            next();
+        });
+    }
+    ensureRoutes(pathname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matchedRoutes = router_1.matchRoutes(this._api.getRoutes(), pathname) || [];
+            const modulesToActivate = matchedRoutes
+                .map(({ route: { component } }) => component ? `${component}?${constants_1.ROUTE_RESOURCE_QUERYSTRING}` : '')
+                .filter(Boolean);
+            return this._activateModules(modulesToActivate);
+        });
+    }
+    _activateModules(modules) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.devMiddleware) {
+                return;
+            }
+            const tasks = modules
+                .map(m => module_replace_plugin_1.default.restoreModule(m))
+                .filter(Boolean);
+            if (tasks.length) {
+                this.devMiddleware.invalidate();
+                yield Promise.all(tasks);
+            }
+        });
+    }
+}
+exports.OnDemandRouteManager = OnDemandRouteManager;

package/lib/lib/renderToHTML.d.ts

@@ -0,0 +1,10 @@
+import { Runtime } from '../types';
+import { Api } from '../api';
+export declare function renderToHTML({ req, api, onRedirect }: {
+    req: Runtime.IRequest;
+    api: Api;
+    onRedirect?(redirect: Runtime.IRenderResultRedirect): void;
+}): Promise<{
+    html: string | null;
+    appContext: any;
+}>;

package/lib/lib/renderToHTML.js

@@ -0,0 +1,52 @@
+"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 renderer_1 = require("../renderer");
+function renderToHTML({ req, api, onRedirect }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let html = null;
+        const renderer = new renderer_1.Renderer({ api });
+        const { application, server: { render } } = api.resources.server;
+        const app = application.create({
+            req
+        }, {
+            render({ appContext, AppComponent, router }) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const result = yield renderer.renderDocument({
+                        router,
+                        app,
+                        AppComponent,
+                        appContext,
+                        render
+                    });
+                    if (renderer_1.isRedirect(result)) {
+                        onRedirect && onRedirect(result);
+                    }
+                    else {
+                        html = result;
+                    }
+                });
+            }
+        });
+        let appContext;
+        try {
+            appContext = yield app.run();
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            yield app.dispose();
+        }
+        return { appContext, html };
+    });
+}
+exports.renderToHTML = renderToHTML;

package/lib/lib/resolveRuntimeCoreFile.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (...paths: string[]) => string;
+export default _default;

package/lib/lib/resolveRuntimeCoreFile.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const runtimeCoreDir = path_1.default.dirname(require.resolve('@shuvi/platform-core/package.json'));
+exports.default = (...paths) => {
+    const filePath = `${path_1.default.join(runtimeCoreDir, 'lib', ...paths)}`;
+    try {
+        require.resolve(filePath);
+    }
+    catch (_a) {
+        throw new Error(`[shuvi-app building] Module under @shuvi/platform-core does not exist (${filePath}). Please check the file path is correct.`);
+    }
+    return filePath;
+};

package/lib/lib/routes.d.ts

@@ -0,0 +1,12 @@
+import { IUserRouteConfig } from '../api';
+import { IRouteRecord } from '@shuvi/router';
+export declare type Templates<T extends {}> = {
+    [K in keyof T]?: (v: T[K], route: T & {
+        id: string;
+    }) => string;
+};
+export declare function serializeRoutes(routes: IUserRouteConfig[], parentPath?: string): string;
+export declare function renameFilepathToComponent(routes: IRouteRecord[]): IUserRouteConfig[];
+export declare function normalizeRoutes(routes: IUserRouteConfig[], option: {
+    componentDir: string;
+}): IUserRouteConfig[];

package/lib/lib/routes.js

@@ -0,0 +1,90 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../constants");
+function genRouteId(filepath) {
+    return crypto_1.createHash('md4').update(filepath).digest('hex').substr(0, 4);
+}
+function serializeRoutes(routes, parentPath = '') {
+    let res = '';
+    for (let index = 0; index < routes.length; index++) {
+        const _a = routes[index], { children: childRoutes } = _a, route = __rest(_a, ["children"]);
+        const fullpath = route.path ? parentPath + '/' + route.path : parentPath;
+        const id = genRouteId(fullpath);
+        let strRoute = `id: ${JSON.stringify(id)},\n`;
+        const keys = Object.keys(route);
+        for (let index = 0; index < keys.length; index++) {
+            const key = keys[index];
+            if (key === 'component') {
+                const { component } = route;
+                const componentSource = component;
+                const componentSourceWithAffix = `${componentSource}?${constants_1.ROUTE_RESOURCE_QUERYSTRING}`;
+                strRoute += `__componentSourceWithAffix__: "${componentSourceWithAffix}",
+__componentSource__: "${componentSource}",
+__import__: () => import(/* webpackChunkName: "page-${id}" */"${componentSourceWithAffix}"),
+__resolveWeak__: () => [require.resolveWeak("${componentSourceWithAffix}")]`.trim();
+            }
+            else {
+                strRoute += `${key}: ${JSON.stringify(route[key])}`;
+            }
+            strRoute += `,\n`;
+        }
+        if (childRoutes && childRoutes.length > 0) {
+            strRoute += `children: ${serializeRoutes(childRoutes, fullpath)},\n`;
+        }
+        res += `{${strRoute}},\n`;
+    }
+    return `[${res}]`;
+}
+exports.serializeRoutes = serializeRoutes;
+function renameFilepathToComponent(routes) {
+    const res = [];
+    for (let index = 0; index < routes.length; index++) {
+        const { path, filepath, children } = routes[index];
+        const route = {
+            path
+        };
+        if (filepath) {
+            route.component = filepath;
+        }
+        if (children && children.length > 0) {
+            route.children = renameFilepathToComponent(children);
+        }
+        res.push(route);
+    }
+    return res;
+}
+exports.renameFilepathToComponent = renameFilepathToComponent;
+function normalizeRoutes(routes, option) {
+    const res = [];
+    for (let index = 0; index < routes.length; index++) {
+        const route = Object.assign({}, routes[index]);
+        if (route.component) {
+            const absPath = path_1.default.isAbsolute(route.component)
+                ? route.component
+                : path_1.default.resolve(option.componentDir, route.component);
+            route.component = absPath.replace(/\\/g, '/');
+        }
+        if (route.children && route.children.length > 0) {
+            route.children = normalizeRoutes(route.children, option);
+        }
+        res.push(route);
+    }
+    return res;
+}
+exports.normalizeRoutes = normalizeRoutes;

package/lib/lib/runtimeConfig.d.ts

@@ -0,0 +1,4 @@
+import { IRuntimeConfig } from '../api';
+declare const _default: () => Record<string, string>;
+export default _default;
+export declare function setRuntimeConfig(config: IRuntimeConfig): void;

package/lib/lib/runtimeConfig.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let runtimeConfig;
+exports.default = () => {
+    return runtimeConfig || {};
+};
+function setRuntimeConfig(config) {
+    runtimeConfig = config;
+}
+exports.setRuntimeConfig = setRuntimeConfig;

package/lib/lib/serveStatic.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+export declare function serveStatic(req: IncomingMessage, res: ServerResponse, path: string): Promise<void>;

package/lib/lib/serveStatic.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const send_1 = __importDefault(require("send"));
+function serveStatic(req, res, path) {
+    return new Promise((resolve, reject) => {
+        send_1.default(req, path)
+            .on('file', () => {
+            res.statusCode = 200;
+        })
+            .on('directory', () => {
+            // We don't allow directories to be read.
+            const err = new Error('No directory access');
+            err.code = 'ENOENT';
+            reject(err);
+        })
+            .on('error', reject)
+            .pipe(res)
+            .on('finish', resolve);
+    });
+}
+exports.serveStatic = serveStatic;

package/lib/lib/utils.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+export declare function acceptsHtml(header: string, { htmlAcceptHeaders }?: {
+    htmlAcceptHeaders?: string[];
+}): boolean;
+export declare function sendHTML(req: IncomingMessage, res: ServerResponse, html: string): void;

package/lib/lib/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function acceptsHtml(header, { htmlAcceptHeaders = ['text/html', '*/*'] } = {}) {
+    for (var i = 0; i < htmlAcceptHeaders.length; i++) {
+        if (header.indexOf(htmlAcceptHeaders[i]) !== -1) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.acceptsHtml = acceptsHtml;
+function sendHTML(req, res, html) {
+    if (res.writableEnded || res.headersSent)
+        return;
+    if (!res.getHeader('Content-Type')) {
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    }
+    const buffer = Buffer.from(html);
+    res.setHeader('Content-Length', buffer.length);
+    // ctx.body will set ctx.status to 200, if ctx.status is not set before
+    if (!res.statusCode)
+        res.statusCode = 200;
+    res.end(req.method === 'HEAD' ? null : buffer);
+}
+exports.sendHTML = sendHTML;

package/lib/lib/viewTemplate.d.ts

@@ -0,0 +1,5 @@
+import { TemplateFunction } from 'ejs';
+export { TemplateFunction };
+declare function parseTemplateFile(templateFile: string): TemplateFunction;
+declare function renderTemplate(templateFn: TemplateFunction, data: any): string;
+export { parseTemplateFile, renderTemplate };

package/lib/lib/viewTemplate.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ejs_1 = __importDefault(require("ejs"));
+const fs_1 = __importDefault(require("fs"));
+function parseTemplateFile(templateFile) {
+    const content = fs_1.default.readFileSync(templateFile, 'utf8');
+    return ejs_1.default.compile(content);
+}
+exports.parseTemplateFile = parseTemplateFile;
+function renderTemplate(templateFn, data) {
+    return templateFn(data);
+}
+exports.renderTemplate = renderTemplate;

package/lib/project/file-manager/errorHandling.d.ts

@@ -0,0 +1 @@
+export declare function callWithErrorHandling(fn: Function, args?: unknown[]): any;

package/lib/project/file-manager/errorHandling.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function callWithErrorHandling(fn, args) {
+    let res;
+    try {
+        res = args ? fn(...args) : fn();
+    }
+    catch (err) {
+        console.error(err);
+    }
+    return res;
+}
+exports.callWithErrorHandling = callWithErrorHandling;

package/lib/project/file-manager/file.d.ts

@@ -0,0 +1,17 @@
+import { ReactiveEffect } from '@vue/reactivity';
+import { FileOptions, FileInternalInstance } from './fileTypes';
+export * from './fileTypes';
+export declare let currentInstance: FileInternalInstance | null;
+export declare const getCurrentInstance: () => FileInternalInstance | null;
+export declare const setCurrentInstance: (instance: FileInternalInstance | null) => void;
+export declare function recordInstanceBoundEffect(effect: ReactiveEffect): void;
+interface ComponentRenderContext {
+    [key: string]: any;
+    _: FileInternalInstance;
+}
+export declare const PublicInstanceProxyHandlers: {
+    get({ _: instance }: ComponentRenderContext, key: string): any;
+    set({ _: instance }: ComponentRenderContext, key: string, value: any): boolean;
+    has({ _: { setupState, accessCache, ctx } }: ComponentRenderContext, key: string): boolean;
+};
+export declare function createFileInstance(options: FileOptions): FileInternalInstance;

package/lib/project/file-manager/file.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@shuvi/utils");
+const lifecycle_1 = require("./lifecycle");
+const scheduler_1 = require("./scheduler");
+const AccessTypes = {
+    SETUP: 0,
+    PROPS: 1,
+    CONTEXT: 2,
+    OTHER: 3,
+    LISTENERS: 4
+};
+exports.currentInstance = null;
+exports.getCurrentInstance = () => exports.currentInstance;
+exports.setCurrentInstance = (instance) => {
+    exports.currentInstance = instance;
+};
+// record effects created during a component's setup() so that they can be
+// stopped when the component unmounts
+function recordInstanceBoundEffect(effect) {
+    if (exports.currentInstance) {
+        (exports.currentInstance.effects || (exports.currentInstance.effects = [])).push(effect);
+    }
+}
+exports.recordInstanceBoundEffect = recordInstanceBoundEffect;
+const publicPropertiesMap = utils_1.extend(Object.create(null), {
+    $setup: i => i.setupState,
+    $forceUpdate: i => () => scheduler_1.queueJob(i.update)
+});
+exports.PublicInstanceProxyHandlers = {
+    get({ _: instance }, key) {
+        const { ctx, setupState, accessCache } = instance;
+        // let @vue/reactivity know it should never observe Vue public instances.
+        if (key === '__v_skip' /* ReactiveFlags.SKIP */) {
+            return true;
+        }
+        const publicGetter = publicPropertiesMap[key];
+        // public $xxx properties
+        if (publicGetter) {
+            return publicGetter(instance);
+        }
+        // data / props / ctx
+        // This getter gets called for every property access on the render context
+        // during render and is a major hotspot. The most expensive part of this
+        // is the multiple hasOwn() calls. It's much faster to do a simple property
+        // access on a plain object, so we use an accessCache object (with null
+        // prototype) to memoize what access type a key corresponds to.
+        if (key[0] !== '$') {
+            const n = accessCache[key];
+            if (n !== undefined) {
+                switch (n) {
+                    case AccessTypes.SETUP:
+                        return setupState[key];
+                    case AccessTypes.CONTEXT:
+                        return ctx[key];
+                    // default: just fallthrough
+                }
+            }
+            else if (setupState !== utils_1.EMPTY_OBJ && utils_1.hasOwn(setupState, key)) {
+                accessCache[key] = AccessTypes.SETUP;
+                return setupState[key];
+            }
+            else if (ctx !== utils_1.EMPTY_OBJ && utils_1.hasOwn(ctx, key)) {
+                accessCache[key] = AccessTypes.CONTEXT;
+                return ctx[key];
+            }
+        }
+        if (ctx !== utils_1.EMPTY_OBJ && utils_1.hasOwn(ctx, key)) {
+            // user may set custom properties to `this` that start with `$`
+            accessCache[key] = AccessTypes.CONTEXT;
+            return ctx[key];
+        }
+    },
+    set({ _: instance }, key, value) {
+        const { setupState, ctx } = instance;
+        if (setupState !== utils_1.EMPTY_OBJ && utils_1.hasOwn(setupState, key)) {
+            setupState[key] = value;
+        }
+        if (key[0] === '$' && key.slice(1) in instance) {
+            return false;
+        }
+        else {
+            ctx[key] = value;
+        }
+        return true;
+    },
+    has({ _: { setupState, accessCache, ctx } }, key) {
+        return (accessCache[key] !== undefined ||
+            (setupState !== utils_1.EMPTY_OBJ && utils_1.hasOwn(setupState, key)) ||
+            utils_1.hasOwn(ctx, key) ||
+            utils_1.hasOwn(publicPropertiesMap, key));
+    }
+};
+function createFileInstance(options) {
+    const instance = {
+        type: options,
+        name: options.name,
+        content: options.content,
+        update: null,
+        destroy: null,
+        proxy: null,
+        accessCache: {},
+        // state
+        ctx: utils_1.EMPTY_OBJ,
+        setupState: utils_1.EMPTY_OBJ,
+        // lifecycle
+        isMounted: false,
+        isUnmounted: false,
+        mounted: [],
+        unmounted: []
+    };
+    instance.ctx = { _: instance };
+    instance.proxy = new Proxy(instance.ctx, exports.PublicInstanceProxyHandlers);
+    const { setup } = options;
+    exports.currentInstance = instance;
+    if (setup) {
+        const setupResult = setup();
+        if (utils_1.isObject(setupResult)) {
+            instance.setupState = setupResult;
+        }
+    }
+    applyOptions(instance, options);
+    exports.currentInstance = null;
+    return instance;
+}
+exports.createFileInstance = createFileInstance;
+function applyOptions(instance, options) {
+    const publicThis = instance.proxy;
+    const { methods: methodsOptions, 
+    // lifecycle
+    mounted, unmounted } = options;
+    const ctx = instance.ctx;
+    if (methodsOptions) {
+        const publicThis = instance.proxy;
+        for (const key in methodsOptions) {
+            // todo: check duplicated
+            ctx[key] = methodsOptions[key].bind(publicThis);
+        }
+    }
+    if (mounted) {
+        lifecycle_1.injectHook('mounted', mounted.bind(publicThis));
+    }
+    if (unmounted) {
+        lifecycle_1.injectHook('unmounted', unmounted.bind(publicThis));
+    }
+}

package/lib/project/file-manager/fileManager.d.ts

@@ -0,0 +1,11 @@
+import { FileOptions } from './file';
+export interface FileManager {
+    addFile(options: FileOptions): void;
+    mount(dir: string): Promise<void>;
+    unmount(): Promise<void>;
+}
+export interface FileManagerOptions {
+    watch?: boolean;
+    context?: any;
+}
+export declare function getFileManager({ watch, context }: FileManagerOptions): FileManager;