xhs-mp-compiler-cli 1.4.0-beta.2 → 1.4.0

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

@@ -1,98 +0,0 @@
-/// <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

@@ -1,90 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-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

@@ -1,23 +0,0 @@
-"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

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