@shuvi/service 0.0.1-pre.1

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

@@ -0,0 +1,86 @@
+"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 path_1 = __importDefault(require("path"));
+const mount_1 = require("./mount");
+const scheduler_1 = require("./scheduler");
+function getFileManager({ watch = false, context }) {
+    let hasMounted = false;
+    let hasUnMounted = false;
+    let rootDir = '';
+    const files = [];
+    const instances = new Map();
+    const addFile = (options) => {
+        if (hasUnMounted) {
+            return;
+        }
+        files.push(Object.assign(Object.assign({}, options), { name: options.name }));
+        if (hasMounted) {
+            scheduler_1.queueJob(() => {
+                mount(rootDir);
+            });
+        }
+    };
+    const _mountFile = (file) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const inst = yield mount_1.mount(file, context, watch);
+            instances.set(file.name, inst);
+        }
+        catch (error) {
+            console.log(`fail to mount file ${file.name}`);
+            console.error(error);
+        }
+    });
+    const mount = (dir) => __awaiter(this, void 0, void 0, function* () {
+        // rootDir is set while mounting
+        rootDir = dir;
+        if (!hasMounted) {
+            hasMounted = true;
+        }
+        const tasks = [];
+        const filesCopy = files.slice();
+        files.length = 0;
+        for (const file of filesCopy) {
+            // rootDir as well as Full path name would not be set until mount
+            file.name = path_1.default.resolve(rootDir, file.name);
+            tasks.push(() => _mountFile(file));
+        }
+        yield Promise.all(tasks.map(task => task()));
+    });
+    const unmount = () => __awaiter(this, void 0, void 0, function* () {
+        const tasks = [];
+        for (const [name, inst] of instances.entries()) {
+            tasks.push(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield inst.destroy();
+                    instances.delete(name);
+                }
+                catch (error) {
+                    console.log(`fail to unmount file ${name}`);
+                    console.error(error);
+                }
+            }));
+        }
+        yield Promise.all(tasks.map(task => task()));
+        instances.clear();
+        hasMounted = false;
+        hasUnMounted = true;
+    });
+    return {
+        addFile,
+        mount,
+        unmount
+    };
+}
+exports.getFileManager = getFileManager;

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

@@ -0,0 +1,56 @@
+import { ReactiveEffect } from '@vue/reactivity';
+export declare type FileLifecycleHooks = 'mounted' | 'unmounted';
+export declare type Data = Record<string, unknown>;
+export interface MethodOptions {
+    [key: string]: Function;
+}
+export interface FileInternalOptions {
+}
+export interface FileOptionsBase<Data, Method extends MethodOptions> extends FileInternalOptions {
+    name: string;
+    content: (this: CreateFilePublicInstance<Data, Method>, ctx: any) => string | null | undefined;
+    setup?: (this: void) => Data | void;
+    methods?: Method;
+    mounted?(): void;
+    unmounted?(): void;
+    [key: string]: any;
+}
+export declare type FileOptions<Data = any, Method extends MethodOptions = any> = FileOptionsBase<Data, Method> & ThisType<CreateFilePublicInstance<Data, Method>>;
+export declare type FilePublicInstance<Data = {}, // return from data()
+Context = {}, Method extends MethodOptions = {}> = {
+    $setup: Data;
+    $context: Context;
+} & Data & Context & Method;
+export declare type CreateFilePublicInstance<Data = {}, Context = {}, Method extends MethodOptions = {}> = FilePublicInstance<Data, Context, Method>;
+export declare type FileInternalContentFunction = (ctx: any, $setup: Data) => string;
+export declare type FileType<Data = any, Method extends MethodOptions = MethodOptions> = FileOptions<Data, Method>;
+export interface FileInternalInstance {
+    name: string;
+    type: FileType;
+    effects?: ReactiveEffect[];
+    /**
+     * The reactive effect for rendering and patching the component. Callable.
+     */
+    update: any;
+    destroy: any;
+    /**
+     * The render function that returns vdom tree.
+     */
+    content: FileInternalContentFunction;
+    /**
+     * cache for proxy access type to avoid hasOwnProperty calls
+     */
+    accessCache: Data | null;
+    proxy: FilePublicInstance | null;
+    /**
+     * This is the target for the public instance proxy. It also holds properties
+     * injected by user options (computed, methods etc.) and user-attached
+     * custom properties (via `this.x = ...`)
+     */
+    ctx: Data;
+    setupState: Data;
+    isMounted: boolean;
+    isUnmounted: boolean;
+    mounted: Function[];
+    unmounted: Function[];
+}

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

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

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

@@ -0,0 +1,7 @@
+import { reactive } from '@vue/reactivity';
+import { getFileManager, FileManager } from './fileManager';
+export type { FileOptions } from './file';
+export { onMounted, onUnmounted } from './lifecycle';
+export { reactive };
+export { getFileManager };
+export type { FileManager };

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reactivity_1 = require("@vue/reactivity");
+exports.reactive = reactivity_1.reactive;
+const fileManager_1 = require("./fileManager");
+exports.getFileManager = fileManager_1.getFileManager;
+var lifecycle_1 = require("./lifecycle");
+exports.onMounted = lifecycle_1.onMounted;
+exports.onUnmounted = lifecycle_1.onUnmounted;

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

@@ -0,0 +1,7 @@
+import { FileLifecycleHooks, FileInternalInstance } from './file';
+export declare function injectHook(type: FileLifecycleHooks, hook: Function & {
+    __weh?: Function;
+}, target?: FileInternalInstance | null, prepend?: boolean): Function | undefined;
+export declare const createHook: <T extends Function = () => any>(lifecycle: FileLifecycleHooks) => (hook: T, target?: FileInternalInstance | null) => Function | undefined;
+export declare const onMounted: (hook: () => any, target?: FileInternalInstance | null) => Function | undefined;
+export declare const onUnmounted: (hook: () => any, target?: FileInternalInstance | null) => Function | undefined;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reactivity_1 = require("@vue/reactivity");
+const errorHandling_1 = require("./errorHandling");
+const file_1 = require("./file");
+function injectHook(type, hook, target = file_1.currentInstance, prepend = false) {
+    if (target) {
+        const hooks = target[type] || (target[type] = []);
+        // cache the error handling wrapper for injected hooks so the same hook
+        // can be properly deduped by the scheduler. "__weh" stands for "with error
+        // handling".
+        const wrappedHook = hook.__weh ||
+            (hook.__weh = (...args) => {
+                if (target.isUnmounted) {
+                    return;
+                }
+                // disable tracking inside all lifecycle hooks
+                // since they can potentially be called inside effects.
+                reactivity_1.pauseTracking();
+                // Set currentInstance during hook invocation.
+                // This assumes the hook does not synchronously trigger other hooks, which
+                // can only be false when the user does something really funky.
+                file_1.setCurrentInstance(target);
+                const res = errorHandling_1.callWithErrorHandling(hook, args);
+                file_1.setCurrentInstance(null);
+                reactivity_1.resetTracking();
+                return res;
+            });
+        if (prepend) {
+            hooks.unshift(wrappedHook);
+        }
+        else {
+            hooks.push(wrappedHook);
+        }
+        return wrappedHook;
+    }
+    return undefined;
+}
+exports.injectHook = injectHook;
+exports.createHook = (lifecycle) => (hook, target = file_1.currentInstance) => injectHook(lifecycle, hook, target);
+exports.onMounted = exports.createHook('mounted');
+exports.onUnmounted = exports.createHook('unmounted');

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

@@ -0,0 +1,3 @@
+import { FileOptions } from './file';
+import { FileInternalInstance } from './fileTypes';
+export declare function mount(options: FileOptions, context: any, watch: boolean): Promise<FileInternalInstance>;

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

@@ -0,0 +1,80 @@
+"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 fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("@shuvi/utils");
+const reactivity_1 = require("@vue/reactivity");
+const file_1 = require("./file");
+const scheduler_1 = require("./scheduler");
+const utils_2 = require("./utils");
+function mount(options, context = {}, watch) {
+    const defer = utils_1.Defer();
+    const instance = file_1.createFileInstance(options);
+    const { content, name: fsPath, setupState } = instance;
+    const dir = path_1.default.dirname(fsPath);
+    let fd;
+    const componentEffect = () => {
+        // mount
+        if (!instance.isMounted) {
+            fs_extra_1.default.ensureDirSync(dir);
+            fd = fs_extra_1.default.openSync(fsPath, 'w+');
+            const fileContent = content(context, setupState);
+            if (fileContent != undefined) {
+                fs_extra_1.default.writeSync(fd, fileContent, 0);
+            }
+            /**
+             * `mounted` hook could be excuted only in watch mode
+             */
+            if (watch) {
+                utils_2.invokeArrayFns(instance.mounted);
+            }
+            instance.isMounted = true;
+            defer.resolve(instance);
+            return;
+        }
+        const fileContent = content(context, setupState);
+        fs_extra_1.default.ftruncateSync(fd, 0);
+        fs_extra_1.default.writeSync(fd, fileContent, 0);
+    };
+    if (watch) {
+        instance.update = reactivity_1.effect(componentEffect, {
+            scheduler: scheduler_1.queueJob,
+            allowRecurse: true
+            // lazy: true,
+        });
+    }
+    else {
+        componentEffect();
+    }
+    instance.destroy = () => {
+        const destroyDefer = utils_1.Defer();
+        const { effects, update, unmounted, name: fsPath } = instance;
+        fs_extra_1.default.removeSync(fsPath);
+        if (effects) {
+            for (let i = 0; i < effects.length; i++) {
+                reactivity_1.stop(effects[i]);
+            }
+        }
+        if (update) {
+            reactivity_1.stop(update);
+        }
+        /**
+         * `unmounted` hook could be excuted only in watch mode
+         */
+        if (watch) {
+            scheduler_1.queuePostFlushCb(() => {
+                utils_2.invokeArrayFns(unmounted);
+            });
+        }
+        scheduler_1.queuePostFlushCb(() => {
+            instance.isUnmounted = true;
+            destroyDefer.resolve();
+        });
+        return destroyDefer.promise;
+    };
+    return defer.promise;
+}
+exports.mount = mount;

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

@@ -0,0 +1,35 @@
+import { FilePublicInstance } from './fileTypes';
+export interface SchedulerJob {
+    (): void;
+    /**
+     * unique job id, only present on raw effects, e.g. component render effect
+     */
+    id?: number;
+    /**
+     * Indicates whether the job is allowed to recursively trigger itself.
+     * By default, a job cannot trigger itself because some built-in method calls,
+     * e.g. Array.prototype.push actually performs reads as well (#1740) which
+     * can lead to confusing infinite loops.
+     * The allowed cases are component update functions and watch callbacks.
+     * Component update functions may update child component props, which in turn
+     * trigger flush: "pre" watch callbacks that mutates state that the parent
+     * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
+     * triggers itself again, it's likely intentional and it is the user's
+     * responsibility to perform recursive state mutation that eventually
+     * stabilizes (#1727).
+     */
+    allowRecurse?: boolean;
+}
+export declare type SchedulerCb = Function & {
+    id?: number;
+};
+export declare type SchedulerCbs = SchedulerCb | SchedulerCb[];
+declare type CountMap = Map<SchedulerJob | SchedulerCb, number>;
+export declare function nextTick(this: FilePublicInstance | void, fn?: () => void): Promise<void>;
+export declare function queueJob(job: SchedulerJob): void;
+export declare function invalidateJob(job: SchedulerJob): void;
+export declare function queuePreFlushCb(cb: SchedulerCb): void;
+export declare function queuePostFlushCb(cb: SchedulerCbs): void;
+export declare function flushPreFlushCbs(seen?: CountMap, parentJob?: SchedulerJob | null): void;
+export declare function flushPostFlushCbs(seen?: CountMap): void;
+export {};

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

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errorHandling_1 = require("./errorHandling");
+const utils_1 = require("@shuvi/utils");
+let isFlushing = false;
+let isFlushPending = false;
+const queue = [];
+let flushIndex = 0;
+const pendingPreFlushCbs = [];
+let activePreFlushCbs = null;
+let preFlushIndex = 0;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = Promise.resolve();
+let currentFlushPromise = null;
+let currentPreFlushParentJob = null;
+const RECURSION_LIMIT = 100;
+const getId = (job) => job.id == null ? Infinity : job.id;
+function nextTick(fn) {
+    const p = currentFlushPromise || resolvedPromise;
+    return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+exports.nextTick = nextTick;
+function queueJob(job) {
+    // the dedupe search uses the startIndex argument of Array.includes()
+    // by default the search index includes the current job that is being run
+    // so it cannot recursively trigger itself again.
+    // if the job is a watch() callback, the search will start with a +1 index to
+    // allow it recursively trigger itself - it is the user's responsibility to
+    // ensure it doesn't end up in an infinite loop.
+    if ((!queue.length ||
+        !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&
+        job !== currentPreFlushParentJob) {
+        queue.push(job);
+        queueFlush();
+    }
+}
+exports.queueJob = queueJob;
+function queueFlush() {
+    if (!isFlushing && !isFlushPending) {
+        isFlushPending = true;
+        currentFlushPromise = resolvedPromise.then(flushJobs);
+    }
+}
+function invalidateJob(job) {
+    const i = queue.indexOf(job);
+    if (i > -1) {
+        queue[i] = null;
+    }
+}
+exports.invalidateJob = invalidateJob;
+function queueCb(cb, activeQueue, pendingQueue, index) {
+    if (!utils_1.isArray(cb)) {
+        if (!activeQueue ||
+            !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {
+            pendingQueue.push(cb);
+        }
+    }
+    else {
+        // if cb is an array, it is a component lifecycle hook which can only be
+        // triggered by a job, which is already deduped in the main queue, so
+        // we can skip duplicate check here to improve perf
+        pendingQueue.push(...cb);
+    }
+    queueFlush();
+}
+function queuePreFlushCb(cb) {
+    queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);
+}
+exports.queuePreFlushCb = queuePreFlushCb;
+function queuePostFlushCb(cb) {
+    queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);
+}
+exports.queuePostFlushCb = queuePostFlushCb;
+function flushPreFlushCbs(seen, parentJob = null) {
+    if (pendingPreFlushCbs.length) {
+        currentPreFlushParentJob = parentJob;
+        activePreFlushCbs = [...new Set(pendingPreFlushCbs)];
+        pendingPreFlushCbs.length = 0;
+        seen = seen || new Map();
+        for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {
+            checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);
+            activePreFlushCbs[preFlushIndex]();
+        }
+        activePreFlushCbs = null;
+        preFlushIndex = 0;
+        currentPreFlushParentJob = null;
+        // recursively flush until it drains
+        flushPreFlushCbs(seen, parentJob);
+    }
+}
+exports.flushPreFlushCbs = flushPreFlushCbs;
+function flushPostFlushCbs(seen) {
+    if (pendingPostFlushCbs.length) {
+        const deduped = [...new Set(pendingPostFlushCbs)];
+        pendingPostFlushCbs.length = 0;
+        // #1947 already has active queue, nested flushPostFlushCbs call
+        if (activePostFlushCbs) {
+            activePostFlushCbs.push(...deduped);
+            return;
+        }
+        activePostFlushCbs = deduped;
+        seen = seen || new Map();
+        activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
+        for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+            checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);
+            activePostFlushCbs[postFlushIndex]();
+        }
+        activePostFlushCbs = null;
+        postFlushIndex = 0;
+    }
+}
+exports.flushPostFlushCbs = flushPostFlushCbs;
+function flushJobs(seen) {
+    isFlushPending = false;
+    isFlushing = true;
+    seen = seen || new Map();
+    flushPreFlushCbs(seen);
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child so its render effect will have smaller
+    //    priority number)
+    // 2. If a component is unmounted during a parent component's update,
+    //    its update can be skipped.
+    // Jobs can never be null before flush starts, since they are only invalidated
+    // during execution of another flushed job.
+    queue.sort((a, b) => getId(a) - getId(b));
+    try {
+        for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+            const job = queue[flushIndex];
+            if (job) {
+                checkRecursiveUpdates(seen, job);
+                errorHandling_1.callWithErrorHandling(job);
+            }
+        }
+    }
+    finally {
+        flushIndex = 0;
+        queue.length = 0;
+        flushPostFlushCbs(seen);
+        isFlushing = false;
+        currentFlushPromise = null;
+        // some postFlushCb queued jobs!
+        // keep flushing until it drains.
+        if (queue.length || pendingPostFlushCbs.length) {
+            flushJobs(seen);
+        }
+    }
+}
+function checkRecursiveUpdates(seen, fn) {
+    if (!seen.has(fn)) {
+        seen.set(fn, 1);
+    }
+    else {
+        const count = seen.get(fn);
+        if (count > RECURSION_LIMIT) {
+            throw new Error(`Maximum recursive updates exceeded. ` +
+                `This means you have a reactive effect that is mutating its own ` +
+                `dependencies and thus recursively triggering itself. Possible sources ` +
+                `include component template, render function, updated hook or ` +
+                `watcher source function.`);
+        }
+        else {
+            seen.set(fn, count + 1);
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export declare const invokeArrayFns: (fns: Function[], arg?: any) => void;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeArrayFns = (fns, arg) => {
+    for (let i = 0; i < fns.length; i++) {
+        fns[i](arg);
+    }
+};

package/lib/project/file-presets/files/core/404.js.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    content: () => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/404.js.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const content = `import user404 from '@shuvi/app/user/404'
+import { page404 as platform404 } from '@shuvi/app/core/platform'
+export default user404 || platform404
+`;
+exports.default = {
+    content: () => content
+};

package/lib/project/file-presets/files/core/apiRoutes.js.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from '../../../projectContext';
+declare const _default: {
+    content: (context: ProjectContext) => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/apiRoutes.js.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    content: (context) => context.apiRoutesContent
+};

package/lib/project/file-presets/files/core/app.js.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    content: () => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/app.js.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const content = `import userApp from '@shuvi/app/user/app'
+import { app as platformApp } from '@shuvi/app/core/platform'
+export default userApp || platformApp
+`;
+exports.default = {
+    content: () => content
+};

package/lib/project/file-presets/files/core/client/application.js.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from '../../../../projectContext';
+declare const _default: {
+    content: (context: ProjectContext) => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/client/application.js.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_snippets_1 = require("../../../../file-snippets");
+const moduleExportProxy = file_snippets_1.moduleExportProxyCreater();
+exports.default = {
+    content: (context) => moduleExportProxy.getContent(context.clientModule.application)
+};

package/lib/project/file-presets/files/core/client/entry.js.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from '../../../../projectContext';
+declare const _default: {
+    content: (context: ProjectContext) => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/client/entry.js.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_snippets_1 = require("../../../../file-snippets");
+const moduleExportProxy = file_snippets_1.moduleExportProxyCreater();
+exports.default = {
+    content: (context) => moduleExportProxy.getContent(context.clientModule.entry)
+};

package/lib/project/file-presets/files/core/platform.js.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from '../../../projectContext';
+declare const _default: {
+    content: (context: ProjectContext) => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/platform.js.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_snippets_1 = require("../../../file-snippets");
+const moduleExportProxy = file_snippets_1.moduleExportProxyCreater();
+exports.default = {
+    content: (context) => moduleExportProxy.getContent(context.platformModule)
+};

package/lib/project/file-presets/files/core/plugins.js.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from '../../../projectContext';
+declare const _default: {
+    content: (context: ProjectContext) => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/plugins.js.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    content: (context) => {
+        const plugins = context.runtimePlugins;
+        let pluginRecord = '';
+        let content = '';
+        plugins.forEach((value, name) => {
+            content += `import ${name} from "${value}"\n`;
+            pluginRecord += `${name},`;
+        });
+        content += `const pluginRecord = {${pluginRecord}}\n`;
+        content += `export { pluginRecord };`;
+        return content;
+    }
+};

package/lib/project/file-presets/files/core/polyfill.js.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from '../../../projectContext';
+declare const _default: {
+    content: (context: ProjectContext) => string;
+};
+export default _default;

package/lib/project/file-presets/files/core/polyfill.js.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    content: (context) => context.polyfills.map(file => `import "${file}"`).join('\n')
+};

package/lib/project/file-presets/files/core/routes.js.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from '../../../projectContext';
+declare const _default: {
+    content: (context: ProjectContext) => string;
+};
+export default _default;