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

package/dist/dev-server/escapeHtml.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * Escapes a string for use in HTML.
+ */
+function escapeHtml(string) {
+    const str = `${string}`;
+    const match = matchHtmlRegExp.exec(str);
+    if (!match) {
+        return str;
+    }
+    let escape;
+    let html = "";
+    let index = 0;
+    let lastIndex = 0;
+    for ({ index } = match; index < str.length; index++) {
+        switch (str.charCodeAt(index)) {
+            // "
+            case 34:
+                escape = "&quot;";
+                break;
+            // &
+            case 38:
+                escape = "&amp;";
+                break;
+            // '
+            case 39:
+                escape = "&#39;";
+                break;
+            // <
+            case 60:
+                escape = "&lt;";
+                break;
+            // >
+            case 62:
+                escape = "&gt;";
+                break;
+            default:
+                continue;
+        }
+        if (lastIndex !== index) {
+            html += str.substring(lastIndex, index);
+        }
+        lastIndex = index + 1;
+        html += escape;
+    }
+    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+exports.default = escapeHtml;

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

@@ -0,0 +1,10 @@
+/// <reference types="node/fs" />
+import { Stats, ReadStream } from 'fs';
+/**
+ * Create a simple ETag.
+ */
+declare function etag(entity: Buffer | ReadStream | Stats): Promise<{
+    hash: string;
+    buffer?: Buffer;
+}>;
+export default etag;

package/dist/dev-server/etag.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+/**
+ * Generate a tag for a stat.
+ */
+function statTag(stat) {
+    const mtime = stat.mtime.getTime().toString(16);
+    const size = stat.size.toString(16);
+    return { hash: `W/"${size}-${mtime}"` };
+}
+/**
+ * Generate an entity tag.
+ */
+function entityTag(entity) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sha1 = (0, crypto_1.createHash)('sha1');
+        if (!Buffer.isBuffer(entity)) {
+            let byteLength = 0;
+            const buffers = [];
+            yield new Promise((resolve, reject) => {
+                entity
+                    .on('data', (chunk) => {
+                    sha1.update(chunk);
+                    buffers.push(chunk);
+                    byteLength += chunk.byteLength;
+                })
+                    .on('end', () => {
+                    resolve(sha1);
+                })
+                    .on('error', reject);
+            });
+            return {
+                buffer: Buffer.concat(buffers),
+                hash: `"${byteLength.toString(16)}-${sha1.digest('base64').substring(0, 27)}"`,
+            };
+        }
+        if (entity.byteLength === 0) {
+            // Fast-path empty
+            return { hash: '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"' };
+        }
+        // Compute hash of entity
+        const hash = sha1.update(entity).digest('base64').substring(0, 27);
+        // Compute length of entity
+        const { byteLength } = entity;
+        return { hash: `"${byteLength.toString(16)}-${hash}"` };
+    });
+}
+/**
+ * Create a simple ETag.
+ */
+function etag(entity) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isStrong = Buffer.isBuffer(entity) || entity.pipe !== undefined;
+        return isStrong
+            ? entityTag(entity)
+            : statTag(entity);
+    });
+}
+exports.default = etag;

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

@@ -0,0 +1,9 @@
+/// <reference types="node/fs" />
+import { Stats } from 'fs';
+import { FilledContext } from '.';
+export interface Extra {
+    stats?: Stats;
+    errorCode?: number;
+}
+declare function getFilenameFromUrl(context: FilledContext, url: string, extra?: Extra): string | undefined;
+export default getFilenameFromUrl;

package/dist/dev-server/getFilenameFromUrl.js

@@ -0,0 +1,102 @@
+"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 url_1 = require("url");
+const querystring_1 = __importDefault(require("querystring"));
+const fs_1 = require("fs");
+const memorize_1 = __importDefault(require("./memorize"));
+const getPaths_1 = __importDefault(require("./getPaths"));
+// eslint-disable-next-line no-undefined
+const memoizedParse = (0, memorize_1.default)(url_1.parse, undefined, (value) => {
+    if (value.pathname) {
+        // eslint-disable-next-line no-param-reassign
+        value.pathname = decode(value.pathname);
+    }
+    return value;
+});
+const UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+/**
+ * decodeURIComponent.
+ *
+ * Allows V8 to only deoptimize this fn instead of all of send().
+ */
+function decode(input) {
+    return querystring_1.default.unescape(input);
+}
+// TODO refactor me in the next major release, this function should return `{ filename, stats, error }`
+// TODO fix redirect logic when `/` at the end, like https://github.com/pillarjs/send/blob/master/index.js#L586
+function getFilenameFromUrl(context, url, extra = {}) {
+    const { options } = context;
+    const paths = (0, getPaths_1.default)(context);
+    let foundFilename;
+    let urlObject;
+    try {
+        // The `url` property of the `request` is contains only  `pathname`, `search` and `hash`
+        urlObject = memoizedParse(url, false, true);
+    }
+    catch (_ignoreError) {
+        return;
+    }
+    for (const { publicPath, outputPath } of paths) {
+        let filename;
+        let publicPathObject;
+        try {
+            publicPathObject = memoizedParse(publicPath !== "auto" && publicPath ? publicPath : "/", false, true);
+        }
+        catch (_ignoreError) {
+            continue;
+        }
+        const { pathname } = urlObject;
+        const { pathname: publicPathPathname } = publicPathObject;
+        if (pathname && pathname.startsWith(publicPathPathname)) {
+            // Null byte(s)
+            if (pathname.includes("\0")) {
+                extra.errorCode = 400;
+                return;
+            }
+            // ".." is malicious
+            if (UP_PATH_REGEXP.test(path_1.default.normalize(`./${pathname}`))) {
+                extra.errorCode = 403;
+                return;
+            }
+            // Strip the `pathname` property from the `publicPath` option from the start of requested url
+            // `/complex/foo.js` => `foo.js`
+            // and add outputPath
+            // `foo.js` => `/home/user/my-project/dist/foo.js`
+            filename = path_1.default.join(outputPath, pathname.slice(publicPathPathname.length));
+            try {
+                extra.stats = (0, fs_1.statSync)(filename);
+            }
+            catch (_ignoreError) {
+                continue;
+            }
+            if (extra.stats.isFile()) {
+                foundFilename = filename;
+                break;
+            }
+            else if (extra.stats.isDirectory() &&
+                (typeof options.index === "undefined" || options.index)) {
+                const indexValue = typeof options.index === "undefined" ||
+                    typeof options.index === "boolean"
+                    ? "index.html"
+                    : options.index;
+                filename = path_1.default.join(filename, indexValue);
+                try {
+                    extra.stats = (0, fs_1.statSync)(filename);
+                }
+                catch (__ignoreError) {
+                    continue;
+                }
+                if (extra.stats.isFile()) {
+                    foundFilename = filename;
+                    break;
+                }
+            }
+        }
+    }
+    return foundFilename;
+}
+exports.default = getFilenameFromUrl;

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

@@ -0,0 +1,6 @@
+import { FilledContext } from ".";
+declare function getPaths(context: FilledContext): {
+    outputPath: string;
+    publicPath: string;
+}[];
+export = getPaths;

package/dist/dev-server/getPaths.js

@@ -0,0 +1,20 @@
+"use strict";
+function getPaths(context) {
+    const { stats, options } = context;
+    const childStats = stats.stats
+        ? stats.stats
+        : [stats];
+    const publicPaths = [];
+    for (const { compilation } of childStats) {
+        // The `output.path` is always present and always absolute
+        const outputPath = compilation.getPath(compilation.outputOptions.path || "");
+        const publicPath = options.publicPath
+            ? compilation.getPath(options.publicPath)
+            : compilation.outputOptions.publicPath
+                ? compilation.getPath(compilation.outputOptions.publicPath)
+                : "";
+        publicPaths.push({ outputPath, publicPath });
+    }
+    return publicPaths;
+}
+module.exports = getPaths;

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

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+/// <reference types="node/http" />
+/// <reference types="node/fs" />
+import { MultiCompiler, Compiler, MultiStats, Stats } from 'xhs-mp-pack';
+import { IncomingMessage, ServerResponse as NodeServerResponse } from "http";
+import { ReadStream } from "fs";
+import type { ExpectedResponse } from "./compatibleAPI";
+import { Extra } from "./getFilenameFromUrl";
+import { AbstractCompiler } from "../compiler";
+export type ExtendedServerResponse = NodeServerResponse & {
+    locals?: {
+        mppack?: {
+            devMiddleware?: Context;
+        };
+    };
+};
+export type Response = ExtendedServerResponse & ExpectedResponse;
+export type NextFunction = (err?: any) => void;
+export type WatchOptions = NonNullable<any>;
+export type Watching = Compiler["watching"];
+export type MultiWatching = ReturnType<MultiCompiler["watch"]>;
+export type OutputFileSystem = {
+    createReadStream?: typeof import("fs").createReadStream;
+    statSync?: typeof import("fs").statSync;
+    lstat?: typeof import("fs").lstat;
+    readFileSync?: typeof import("fs").readFileSync;
+};
+type Logger = ReturnType<Compiler["getInfrastructureLogger"]>;
+interface ResponseData {
+    data: Buffer | ReadStream;
+    byteLength: number;
+}
+export { IncomingMessage };
+type ModifyResponseData = (req: Request, res: Response, data: Buffer | ReadStream, byteLength: number) => ResponseData;
+export interface Context {
+    state: boolean;
+    stats: Stats | MultiStats | undefined;
+    callbacks: Array<(stats?: Stats | MultiStats) => void>;
+    options: Options;
+    compiler: Compiler | MultiCompiler;
+    watching: Watching | MultiWatching | undefined;
+    logger: Logger;
+    outputFileSystem: OutputFileSystem;
+}
+export type FilledContext = Omit<Context, "watching"> & {
+    watching: Watching | MultiWatching;
+};
+type NormalizedHeaders = Record<string, string | number> | Array<{
+    key: string;
+    value: number | string;
+}>;
+type Headers = NormalizedHeaders | ((req: Request, res: Response, context: Context) => void | undefined | NormalizedHeaders) | undefined;
+interface Options {
+    mimeTypes?: {
+        [key: string]: string;
+    };
+    mimeTypeDefault?: string;
+    writeToDisk?: boolean | ((targetPath: string) => boolean);
+    methods?: string[];
+    headers?: Headers;
+    publicPath?: NonNullable<any>["publicPath"];
+    stats?: Stats;
+    serverSideRender?: boolean;
+    outputFileSystem?: OutputFileSystem;
+    index?: boolean | string;
+    modifyResponseData?: ModifyResponseData;
+    etag?: "weak" | "strong";
+    lastModified?: boolean;
+}
+type Middleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+type GetFilenameFromUrl = (url: string, extra?: Extra) => string | undefined;
+type WaitUntilValid = (callback: (stats?: Stats | MultiStats) => void) => void;
+type Invalidate = (callback: (stats?: Stats | MultiStats) => void) => void;
+type Close = (callback: (err: Error | null | undefined) => void) => void;
+interface AdditionalMethods {
+    getFilenameFromUrl: GetFilenameFromUrl;
+    waitUntilValid: WaitUntilValid;
+    invalidate: Invalidate;
+    close: Close;
+    context: Context;
+}
+type API = Middleware & AdditionalMethods;
+declare function MPPackMiddleware(compiler: AbstractCompiler, options?: Options): API;
+declare namespace MPPackMiddleware {
+    var koaWrapper: (compiler: AbstractCompiler, options?: Options | undefined) => {
+        (ctx: {
+            req: Request;
+            res: Response;
+            status: number;
+            body: Buffer | ReadStream | {
+                message: string;
+            };
+            state: Object;
+        }, next: Function): Promise<unknown>;
+        devMiddleware: API;
+    };
+}
+export default MPPackMiddleware;

package/dist/dev-server/index.js

@@ -0,0 +1,90 @@
+"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 });
+exports.IncomingMessage = void 0;
+const mime_types_1 = __importDefault(require("mime-types"));
+const middleware_1 = __importDefault(require("./middleware"));
+const getFilenameFromUrl_1 = __importDefault(require("./getFilenameFromUrl"));
+const ready_1 = __importDefault(require("./ready"));
+const http_1 = require("http");
+Object.defineProperty(exports, "IncomingMessage", { enumerable: true, get: function () { return http_1.IncomingMessage; } });
+function MPPackMiddleware(compiler, options = {}) {
+    const { mimeTypes } = options;
+    if (mimeTypes) {
+        const { types } = mime_types_1.default;
+        mime_types_1.default.types = Object.assign(Object.assign({}, types), mimeTypes);
+    }
+    const context = {
+        state: false,
+        stats: undefined,
+        callbacks: [],
+        options,
+        compiler,
+        logger: console,
+    };
+    const filledContext = context;
+    const instance = (0, middleware_1.default)(filledContext);
+    instance.getFilenameFromUrl = (url, extra) => (0, getFilenameFromUrl_1.default)(filledContext, url, extra);
+    instance.waitUntilValid = (callback = () => { }) => {
+        (0, ready_1.default)(filledContext, callback);
+    };
+    instance.invalidate = (callback = () => { }) => {
+        (0, ready_1.default)(filledContext, callback);
+        filledContext.watching.invalidate();
+    };
+    instance.close = (callback = () => { }) => {
+        filledContext.watching.close(callback);
+    };
+    instance.context = filledContext;
+    return instance;
+}
+function koaWrapper(compiler, options) {
+    const devMiddleware = MPPackMiddleware(compiler, options);
+    const wrapper = function mppackDevMiddleware(ctx, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const { req } = ctx;
+                const { res } = ctx;
+                res.locals = ctx.state;
+                res.status = (status) => {
+                    ctx.status = status;
+                };
+                res.pipeInto = (stream) => {
+                    ctx.body = stream;
+                    resolve(null);
+                };
+                res.send = (content) => {
+                    ctx.body = content;
+                    resolve(null);
+                };
+                devMiddleware(req, res, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(next());
+                }).catch((err) => {
+                    ctx.status = err.statusCode || err.status || 500;
+                    ctx.body = {
+                        message: err.message,
+                    };
+                });
+            });
+        });
+    };
+    wrapper.devMiddleware = devMiddleware;
+    return wrapper;
+}
+MPPackMiddleware.koaWrapper = koaWrapper;
+exports.default = MPPackMiddleware;

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

@@ -0,0 +1,7 @@
+type Callback<T> = (value: T) => T;
+declare function memorize<T>(fn: Function, { cache }?: {
+    cache?: Map<string, {
+        data: T;
+    }>;
+}, callback?: Callback<T>): (...args: any[]) => any;
+export = memorize;

package/dist/dev-server/memorize.js

@@ -0,0 +1,23 @@
+"use strict";
+const cacheStore = new WeakMap();
+function memorize(fn, { cache = new Map() } = {}, callback) {
+    const memoized = (...arguments_) => {
+        const [key] = arguments_;
+        const cacheItem = cache.get(key);
+        if (cacheItem) {
+            return cacheItem.data;
+        }
+        // @ts-ignore
+        let result = fn.apply(this, arguments_);
+        if (callback) {
+            result = callback(result);
+        }
+        cache.set(key, {
+            data: result,
+        });
+        return result;
+    };
+    cacheStore.set(memoized, cache);
+    return memoized;
+}
+module.exports = memorize;

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

@@ -0,0 +1,2 @@
+declare function wrapper(context: any): (req: any, res: any, next: any) => Promise<void>;
+export default wrapper;