xhs-mp-compiler-cli 1.3.4 → 1.4.0-beta.1

package/dist/dev-server/middleware.js

@@ -0,0 +1,477 @@
+"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 path = require('path');
+const mime = require('mime-types');
+const onFinishedStream = require('on-finished');
+const getFilenameFromUrl = require('./getFilenameFromUrl');
+const { setStatusCode, send, pipe, createReadStreamOrReadFileSync } = require('./compatibleAPI');
+const ready = require('./ready');
+const parseTokenList = require('./parseTokenList');
+const memorize = require('./memorize');
+const BYTES_RANGE_REGEXP = /^ *bytes/i;
+function getValueContentRangeHeader(type, size, range) {
+    return `${type} ${range ? `${range.start}-${range.end}` : '*'}/${size}`;
+}
+function parseHttpDate(date) {
+    const timestamp = date && Date.parse(date);
+    // istanbul ignore next: guard against date.js Date.parse patching
+    return typeof timestamp === 'number' ? timestamp : NaN;
+}
+const CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
+function destroyStream(stream, suppress) {
+    if (typeof stream.destroy === 'function') {
+        stream.destroy();
+    }
+    if (typeof stream.close === 'function') {
+        // Node.js core bug workaround
+        stream.on('open', function onOpenClose() {
+            // @ts-ignore
+            if (typeof this.fd === 'number') {
+                // actually close down the fd
+                this.close();
+            }
+        });
+    }
+    if (typeof stream.addListener === 'function' && suppress) {
+        stream.removeAllListeners('error');
+        stream.addListener('error', () => { });
+    }
+}
+const statuses = {
+    400: 'Bad Request',
+    403: 'Forbidden',
+    404: 'Not Found',
+    416: 'Range Not Satisfiable',
+    500: 'Internal Server Error'
+};
+const parseRangeHeaders = memorize((value) => {
+    const [len, rangeHeader] = value.split('|');
+    // eslint-disable-next-line global-require
+    return require('range-parser')(Number(len), rangeHeader, {
+        combine: true
+    });
+});
+function wrapper(context) {
+    return function middleware(req, res, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const acceptedMethods = context.options.methods || ['GET', 'HEAD'];
+            // fixes #282. credit @cexoso. in certain edge situations res.locals is undefined.
+            // eslint-disable-next-line no-param-reassign
+            res.locals = res.locals || {};
+            function goNext() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!context.options.serverSideRender) {
+                        return next();
+                    }
+                    return new Promise(resolve => {
+                        ready(context, () => {
+                            res.locals.webpack = { devMiddleware: context };
+                            resolve(next());
+                        }, req);
+                    });
+                });
+            }
+            if (req.method && !acceptedMethods.includes(req.method)) {
+                yield goNext();
+                return;
+            }
+            function sendError(status, options) {
+                // eslint-disable-next-line global-require
+                const escapeHtml = require('./escapeHtml');
+                const content = statuses[status] || String(status);
+                let document = Buffer.from(`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Error</title>
+</head>
+<body>
+<pre>${escapeHtml(content)}</pre>
+</body>
+</html>`, 'utf-8');
+                // Clear existing headers
+                const headers = res.getHeaderNames();
+                for (let i = 0; i < headers.length; i++) {
+                    res.removeHeader(headers[i]);
+                }
+                if (options && options.headers) {
+                    const keys = Object.keys(options.headers);
+                    for (let i = 0; i < keys.length; i++) {
+                        const key = keys[i];
+                        const value = options.headers[key];
+                        if (typeof value !== 'undefined') {
+                            res.setHeader(key, value);
+                        }
+                    }
+                }
+                // Send basic response
+                setStatusCode(res, status);
+                res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                res.setHeader('Content-Security-Policy', "default-src 'none'");
+                res.setHeader('X-Content-Type-Options', 'nosniff');
+                let byteLength = Buffer.byteLength(document);
+                if (options && options.modifyResponseData) {
+                    ;
+                    ({ data: document, byteLength } = options.modifyResponseData(req, res, document, byteLength));
+                }
+                res.setHeader('Content-Length', byteLength);
+                res.end(document);
+            }
+            function isConditionalGET() {
+                return (req.headers['if-match'] ||
+                    req.headers['if-unmodified-since'] ||
+                    req.headers['if-none-match'] ||
+                    req.headers['if-modified-since']);
+            }
+            function isPreconditionFailure() {
+                // if-match
+                const ifMatch = req.headers['if-match'];
+                // A recipient MUST ignore If-Unmodified-Since if the request contains
+                // an If-Match header field; the condition in If-Match is considered to
+                // be a more accurate replacement for the condition in
+                // If-Unmodified-Since, and the two are only combined for the sake of
+                // interoperating with older intermediaries that might not implement If-Match.
+                if (ifMatch) {
+                    const etag = res.getHeader('ETag');
+                    return (!etag ||
+                        (ifMatch !== '*' &&
+                            parseTokenList(ifMatch).every(match => match !== etag && match !== `W/${etag}` && `W/${match}` !== etag)));
+                }
+                // if-unmodified-since
+                const ifUnmodifiedSince = req.headers['if-unmodified-since'];
+                if (ifUnmodifiedSince) {
+                    const unmodifiedSince = parseHttpDate(ifUnmodifiedSince);
+                    // A recipient MUST ignore the If-Unmodified-Since header field if the
+                    // received field-value is not a valid HTTP-date.
+                    if (!isNaN(unmodifiedSince)) {
+                        const lastModified = parseHttpDate(/** @type {string} */ res.getHeader('Last-Modified'));
+                        return isNaN(lastModified) || lastModified > unmodifiedSince;
+                    }
+                }
+                return false;
+            }
+            function isCachable() {
+                return (res.statusCode >= 200 && res.statusCode < 300) || res.statusCode === 304;
+            }
+            function isFresh(resHeaders) {
+                // Always return stale when Cache-Control: no-cache to support end-to-end reload requests
+                // https://tools.ietf.org/html/rfc2616#section-14.9.4
+                const cacheControl = req.headers['cache-control'];
+                if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) {
+                    return false;
+                }
+                // fields
+                const noneMatch = req.headers['if-none-match'];
+                const modifiedSince = req.headers['if-modified-since'];
+                // unconditional request
+                if (!noneMatch && !modifiedSince) {
+                    return false;
+                }
+                // if-none-match
+                if (noneMatch && noneMatch !== '*') {
+                    if (!resHeaders.etag) {
+                        return false;
+                    }
+                    const matches = parseTokenList(noneMatch);
+                    let etagStale = true;
+                    for (let i = 0; i < matches.length; i++) {
+                        const match = matches[i];
+                        if (match === resHeaders.etag ||
+                            match === `W/${resHeaders.etag}` ||
+                            `W/${match}` === resHeaders.etag) {
+                            etagStale = false;
+                            break;
+                        }
+                    }
+                    if (etagStale) {
+                        return false;
+                    }
+                }
+                // A recipient MUST ignore If-Modified-Since if the request contains an If-None-Match header field;
+                // the condition in If-None-Match is considered to be a more accurate replacement for the condition in If-Modified-Since,
+                // and the two are only combined for the sake of interoperating with older intermediaries that might not implement If-None-Match.
+                if (noneMatch) {
+                    return true;
+                }
+                // if-modified-since
+                if (modifiedSince) {
+                    const lastModified = resHeaders['last-modified'];
+                    //  A recipient MUST ignore the If-Modified-Since header field if the
+                    //  received field-value is not a valid HTTP-date, or if the request
+                    //  method is neither GET nor HEAD.
+                    const modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince));
+                    if (modifiedStale) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            function isRangeFresh() {
+                const ifRange = 
+                /** @type {string | undefined} */
+                req.headers['if-range'];
+                if (!ifRange) {
+                    return true;
+                }
+                // if-range as etag
+                if (ifRange.indexOf('"') !== -1) {
+                    const etag = res.getHeader('ETag');
+                    if (!etag) {
+                        return true;
+                    }
+                    return Boolean(etag && ifRange.indexOf(etag) !== -1);
+                }
+                // if-range as modified date
+                const lastModified = res.getHeader('Last-Modified');
+                if (!lastModified) {
+                    return true;
+                }
+                return parseHttpDate(lastModified) <= parseHttpDate(ifRange);
+            }
+            function getRangeHeader() {
+                const rage = req.headers.range;
+                if (rage && BYTES_RANGE_REGEXP.test(rage)) {
+                    return rage;
+                }
+                // eslint-disable-next-line no-undefined
+                return undefined;
+            }
+            function getOffsetAndLenFromRange(range) {
+                const offset = range.start;
+                const len = range.end - range.start + 1;
+                return [offset, len];
+            }
+            function calcStartAndEnd(offset, len) {
+                const start = offset;
+                const end = Math.max(offset, offset + len - 1);
+                return [start, end];
+            }
+            function processRequest() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const extra = {};
+                    const filename = getFilenameFromUrl(context, req.url, extra);
+                    if (extra.errorCode) {
+                        if (extra.errorCode === 403) {
+                            context.logger.error(`Malicious path "${filename}".`);
+                        }
+                        sendError(extra.errorCode, {
+                            modifyResponseData: context.options.modifyResponseData
+                        });
+                        return;
+                    }
+                    if (!filename) {
+                        yield goNext();
+                        return;
+                    }
+                    const { size } = extra.stats;
+                    let len = size;
+                    let offset = 0;
+                    // Send logic
+                    let { headers } = context.options;
+                    if (typeof headers === 'function') {
+                        headers = headers(req, res, context);
+                    }
+                    const allHeaders = [];
+                    if (typeof headers !== 'undefined') {
+                        if (!Array.isArray(headers)) {
+                            // eslint-disable-next-line guard-for-in
+                            for (const name in headers) {
+                                allHeaders.push({ key: name, value: headers[name] });
+                            }
+                            headers = allHeaders;
+                        }
+                        headers.forEach(header => {
+                            res.setHeader(header.key, header.value);
+                        });
+                    }
+                    if (!res.getHeader('Content-Type')) {
+                        // content-type name(like application/javascript; charset=utf-8) or false
+                        const contentType = mime.contentType(path.extname(filename));
+                        // Only set content-type header if media type is known
+                        // https://tools.ietf.org/html/rfc7231#section-3.1.1.5
+                        if (contentType) {
+                            res.setHeader('Content-Type', contentType);
+                        }
+                        else if (context.options.mimeTypeDefault) {
+                            res.setHeader('Content-Type', context.options.mimeTypeDefault);
+                        }
+                    }
+                    if (!res.getHeader('Accept-Ranges')) {
+                        res.setHeader('Accept-Ranges', 'bytes');
+                    }
+                    if (context.options.lastModified && !res.getHeader('Last-Modified')) {
+                        const modified = extra.stats.mtime.toUTCString();
+                        res.setHeader('Last-Modified', modified);
+                    }
+                    let start;
+                    let end;
+                    let bufferOrStream;
+                    let byteLength;
+                    const rangeHeader = getRangeHeader();
+                    if (context.options.etag && !res.getHeader('ETag')) {
+                        let value;
+                        // TODO cache etag generation?
+                        if (context.options.etag === 'weak') {
+                            value = extra.stats;
+                        }
+                        else {
+                            if (rangeHeader) {
+                                const parsedRanges = parseRangeHeaders(`${size}|${rangeHeader}`);
+                                if (parsedRanges !== -2 && parsedRanges !== -1 && parsedRanges.length === 1) {
+                                    ;
+                                    [offset, len] = getOffsetAndLenFromRange(parsedRanges[0]);
+                                }
+                            }
+                            ;
+                            [start, end] = calcStartAndEnd(offset, len);
+                            try {
+                                const result = createReadStreamOrReadFileSync(filename, context.outputFileSystem, start, end);
+                                value = result.bufferOrStream;
+                                ({ bufferOrStream, byteLength } = result);
+                            }
+                            catch (_err) {
+                                // Ignore here
+                            }
+                        }
+                        if (value) {
+                            // eslint-disable-next-line global-require
+                            const result = yield require('./etag')(value);
+                            // Because we already read stream, we can cache buffer to avoid extra read from fs
+                            if (result.buffer) {
+                                bufferOrStream = result.buffer;
+                            }
+                            res.setHeader('ETag', result.hash);
+                        }
+                    }
+                    // Conditional GET support
+                    if (isConditionalGET()) {
+                        if (isPreconditionFailure()) {
+                            sendError(412, {
+                                modifyResponseData: context.options.modifyResponseData
+                            });
+                            return;
+                        }
+                        // For Koa
+                        if (res.statusCode === 404) {
+                            setStatusCode(res, 200);
+                        }
+                        if (isCachable() &&
+                            isFresh({
+                                etag: res.getHeader('ETag'),
+                                'last-modified': res.getHeader('Last-Modified')
+                            })) {
+                            setStatusCode(res, 304);
+                            // Remove content header fields
+                            res.removeHeader('Content-Encoding');
+                            res.removeHeader('Content-Language');
+                            res.removeHeader('Content-Length');
+                            res.removeHeader('Content-Range');
+                            res.removeHeader('Content-Type');
+                            res.end();
+                            return;
+                        }
+                    }
+                    if (rangeHeader) {
+                        let parsedRanges = parseRangeHeaders(`${size}|${rangeHeader}`);
+                        // If-Range support
+                        if (!isRangeFresh()) {
+                            parsedRanges = [];
+                        }
+                        if (parsedRanges === -1) {
+                            context.logger.error("Unsatisfiable range for 'Range' header.");
+                            res.setHeader('Content-Range', getValueContentRangeHeader('bytes', size));
+                            sendError(416, {
+                                headers: {
+                                    'Content-Range': res.getHeader('Content-Range')
+                                },
+                                modifyResponseData: context.options.modifyResponseData
+                            });
+                            return;
+                        }
+                        else if (parsedRanges === -2) {
+                            context.logger.error("A malformed 'Range' header was provided. A regular response will be sent for this request.");
+                        }
+                        else if (parsedRanges.length > 1) {
+                            context.logger.error("A 'Range' header with multiple ranges was provided. Multiple ranges are not supported, so a regular response will be sent for this request.");
+                        }
+                        if (parsedRanges !== -2 && parsedRanges.length === 1) {
+                            // Content-Range
+                            setStatusCode(res, 206);
+                            res.setHeader('Content-Range', getValueContentRangeHeader('bytes', size, parsedRanges[0]));
+                            [offset, len] = getOffsetAndLenFromRange(parsedRanges[0]);
+                        }
+                    }
+                    // When strong Etag generation is enabled we already read file, so we can skip extra fs call
+                    if (!bufferOrStream) {
+                        ;
+                        [start, end] = calcStartAndEnd(offset, len);
+                        try {
+                            ;
+                            ({ bufferOrStream, byteLength } = createReadStreamOrReadFileSync(filename, context.outputFileSystem, start, end));
+                        }
+                        catch (_ignoreError) {
+                            yield goNext();
+                            return;
+                        }
+                    }
+                    if (context.options.modifyResponseData) {
+                        ;
+                        ({ data: bufferOrStream, byteLength } = context.options.modifyResponseData(req, res, bufferOrStream, byteLength));
+                    }
+                    res.setHeader('Content-Length', byteLength);
+                    if (req.method === 'HEAD') {
+                        // For Koa
+                        if (res.statusCode === 404) {
+                            setStatusCode(res, 200);
+                        }
+                        res.end();
+                        return;
+                    }
+                    const isPipeSupports = typeof bufferOrStream.pipe === 'function';
+                    if (!isPipeSupports) {
+                        send(res, bufferOrStream);
+                        return;
+                    }
+                    // Cleanup
+                    const cleanup = () => {
+                        destroyStream(bufferOrStream, true);
+                    };
+                    // Error handling
+                    bufferOrStream.on('error', error => {
+                        // clean up stream early
+                        cleanup();
+                        // Handle Error
+                        switch (error.code) {
+                            case 'ENAMETOOLONG':
+                            case 'ENOENT':
+                            case 'ENOTDIR':
+                                sendError(404, {
+                                    modifyResponseData: context.options.modifyResponseData
+                                });
+                                break;
+                            default:
+                                sendError(500, {
+                                    modifyResponseData: context.options.modifyResponseData
+                                });
+                                break;
+                        }
+                    });
+                    pipe(res, bufferOrStream);
+                    // Response finished, cleanup
+                    onFinishedStream(res, cleanup);
+                });
+            }
+            ready(context, processRequest, req);
+        });
+    };
+}
+exports.default = wrapper;

package/dist/dev-server/ready.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { FilledContext } from ".";
+declare function ready(context: FilledContext, callback: (...args: any[]) => any, req?: Request): void;
+export = ready;

package/dist/dev-server/ready.js

@@ -0,0 +1,11 @@
+"use strict";
+function ready(context, callback, req) {
+    if (context.state) {
+        callback(context.stats);
+        return;
+    }
+    const name = (req && req.url) || callback.name;
+    context.logger.info(`wait until bundle finished${name ? `: ${name}` : ""}`);
+    context.callbacks.push(callback);
+}
+module.exports = ready;

package/dist/index.d.ts

@@ -3,12 +3,12 @@ import { COMPILE_ENTRY } from './config/constant.config';
 import { Project } from 'xhs-mp-project';
 import EventEmitter from 'events';
 import { Logger } from 'xhs-mp-utils';
-import { getProcessCompilerClass } from './compiler';
+import { getProjectCompilerClass } from './compiler';
 interface ILibFeatures {
     supportV2?: boolean;
     supportVdom?: boolean;
 }
-export { COMPILE_ENTRY, getProcessCompilerClass };
+export { COMPILE_ENTRY, getProjectCompilerClass, };
 export type ICompileOpts = {
     logger?: any;
     compileDir?: string;
@@ -50,7 +50,7 @@ export interface ISubPackages {
     root: string;
     pages: string;
 }
-export declare class Compiler extends EventEmitter {
+export declare class ProjectCompiler extends EventEmitter {
     projectPath: string;
     compilerProps: ICompilerProps;
     project: Project;

package/dist/index.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compiler = exports.getProcessCompilerClass = exports.COMPILE_ENTRY = void 0;
+exports.ProjectCompiler = exports.getProjectCompilerClass = exports.COMPILE_ENTRY = void 0;
 const constant_config_1 = require("./config/constant.config");
 Object.defineProperty(exports, "COMPILE_ENTRY", { enumerable: true, get: function () { return constant_config_1.COMPILE_ENTRY; } });
 const xhs_mp_project_1 = require("xhs-mp-project");
@@ -24,8 +24,8 @@ const zip_1 = require("./utils/zip");
 const project_1 = require("./utils/project");
 const dir_config_1 = require("./config/dir.config");
 const compiler_1 = require("./compiler");
-Object.defineProperty(exports, "getProcessCompilerClass", { enumerable: true, get: function () { return compiler_1.getProcessCompilerClass; } });
-class Compiler extends events_1.default {
+Object.defineProperty(exports, "getProjectCompilerClass", { enumerable: true, get: function () { return compiler_1.getProjectCompilerClass; } });
+class ProjectCompiler extends events_1.default {
     constructor(props) {
         super();
         this.compilerImplMap = {};
@@ -203,7 +203,7 @@ class Compiler extends events_1.default {
         };
         this.removeDistDir(entryType);
         this.removeCacheDir(entryType);
-        const CompilerClass = (0, compiler_1.getProcessCompilerClass)(compilerType);
+        const CompilerClass = (0, compiler_1.getProjectCompilerClass)(compilerType);
         const compilerImpl = new CompilerClass(options, {
             logger: this.logger,
             nodeJsPath
@@ -453,4 +453,4 @@ class Compiler extends events_1.default {
         delete this.compilerImplMap[entryType];
     }
 }
-exports.Compiler = Compiler;
+exports.ProjectCompiler = ProjectCompiler;

package/dist/packs/mp-pack/index.js

@@ -9,7 +9,6 @@ const path_1 = __importDefault(require("path"));
 const xhs_mp_pack_1 = require("xhs-mp-pack");
 const apm_1 = require("../../utils/apm");
 const createCompiler = (startConfig) => {
-    const { action, enableDevServer } = startConfig;
     const mppack = new xhs_mp_pack_1.MPPack(startConfig);
     const compilerOptions = {
         project: mppack.project,

package/dist/packs/webpack/dev-server/index.js

@@ -19,6 +19,7 @@ const openBrowser_1 = __importDefault(require("./lib/openBrowser"));
 const presets_1 = require("../../../presets");
 const devServer = (config) => __awaiter(void 0, void 0, void 0, function* () {
     const { packSetting } = config;
+    // @ts-ignore
     const { devServerPort, distDir } = packSetting;
     const webpackConfigs = (0, presets_1.createConfigs)(config);
     const compiler = (0, webpack_1.default)(webpackConfigs);

package/dist/packs/webpack/index.d.ts

@@ -1,3 +1,3 @@
 import { IStart } from '../../types';
 import { WebPack } from './webpack';
-export declare const createCompiler: (startConfig: IStart) => Promise<void> | WebPack;
+export declare const createCompiler: (startConfig: IStart) => WebPack;

package/dist/packs/webpack/index.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompiler = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const dev_server_1 = __importDefault(require("./dev-server"));
 const projectConfig_1 = require("../../utils/projectConfig");
 const common_1 = require("../../utils/common");
 const types_1 = require("../../types");
@@ -88,9 +87,9 @@ const createCompiler = (startConfig) => {
         // cli的node_modules路径
         (_d = (_c = config.resolve) === null || _c === void 0 ? void 0 : _c.modules) === null || _d === void 0 ? void 0 : _d.push(path_1.default.resolve(__dirname, '../../../'));
     });
-    if (action === 'dev' && enableDevServer) {
-        return (0, dev_server_1.default)(compilerOptions);
-    }
+    // if (action === 'dev' && enableDevServer) {
+    //   return webpackDevServer(compilerOptions)
+    // }
     return new webpack_1.WebPack(webpackConfig, compilerOptions);
 };
 exports.createCompiler = createCompiler;

package/dist/packs/webpack/webpack.d.ts

@@ -10,7 +10,7 @@ export declare class WebPack extends AbstractMPPack {
     packSetting: MPPackSetting;
     hadWatch: boolean;
     constructor(configs: any, options: IPresetOptions);
-    handleProgress: (progress: any) => void;
+    handleProgress: (percentage: any, status: any, info: any) => void;
     get hooks(): any;
     watch(config: any, callback?: any): Promise<unknown>;
     changeCompileOptions(config: any): void;

package/dist/packs/webpack/webpack.js

@@ -25,8 +25,12 @@ class WebPack extends xhs_mp_pack_1.AbstractMPPack {
         this.compiler = null;
         this.watcher = null;
         this.hadWatch = false;
-        this.handleProgress = progress => {
-            this.emit('progress', progress);
+        this.handleProgress = (percentage, status, info) => {
+            this.emit('progress', {
+                percentage,
+                status,
+                info
+            });
         };
         this.project = options.project;
         this.packSetting = options.packSetting;

package/dist/presets/configs/miniprogram/render/index.d.ts

@@ -1,5 +1,4 @@
 import { Config } from '../../../../packs';
 import { IPresetOptions } from '../../../../types';
-declare const getRenderEntry: (options: IPresetOptions) => () => {};
-declare const presetRender: (chain: Config, options: IPresetOptions) => void;
-export { getRenderEntry, presetRender };
+export declare const getRenderEntry: (options: IPresetOptions) => () => {};
+export declare const presetRender: (chain: Config, options: IPresetOptions) => void;

package/dist/presets/configs/miniprogram/render/index.js

@@ -13,8 +13,8 @@ const renderChunkPlugin_1 = __importDefault(require("./renderChunkPlugin"));
 const types_1 = require("../../../../types");
 const InjectorPlugin_1 = require("../../../plugins/InjectorPlugin");
 const getRenderEntry = (options) => () => {
-    const res = Object.assign(Object.assign({}, (0, render_1.getRenderEntry)(options)), (0, component_1.getComponentEntry)(options));
-    return res;
+    const entries = Object.assign(Object.assign({}, (0, render_1.getRenderEntry)(options)), (0, component_1.getComponentEntry)(options));
+    return entries;
 };
 exports.getRenderEntry = getRenderEntry;
 const presetRender = (chain, options) => {

package/dist/presets/configs/miniprogram/service/index.js

@@ -43,6 +43,7 @@ const presetService = (chain, options) => {
     const { packSetting } = options;
     const { env, distDir, cacheDirectory } = packSetting;
     chain.merge({
+        // target: 'webworker',
         output: {
             path: distDir,
             globalObject: 'globalThis',

package/dist/sharedFs.d.ts

@@ -0,0 +1,2 @@
+declare const sharedFs: any;
+export default sharedFs;