完成中转仓管理

datav/node_modules/http-proxy-middleware/dist/legacy/create-proxy-middleware.d.ts

@@ -0,0 +1,12 @@
+import { Filter, RequestHandler } from '../types';
+import { LegacyOptions } from './types';
+import type * as http from 'http';
+/**
+ * @deprecated
+ * This function is deprecated and will be removed in a future version.
+ *
+ * Use {@link createProxyMiddleware} instead.
+ */
+export declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(shortHand: string): RequestHandler<TReq, TRes>;
+export declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(legacyOptions: LegacyOptions<TReq, TRes>): RequestHandler<TReq, TRes>;
+export declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(legacyContext: Filter<TReq>, legacyOptions: LegacyOptions<TReq, TRes>): RequestHandler<TReq, TRes>;

datav/node_modules/http-proxy-middleware/dist/legacy/create-proxy-middleware.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyCreateProxyMiddleware = legacyCreateProxyMiddleware;
+const factory_1 = require("../factory");
+const debug_1 = require("../debug");
+const options_adapter_1 = require("./options-adapter");
+const debug = debug_1.Debug.extend('legacy-create-proxy-middleware');
+function legacyCreateProxyMiddleware(legacyContext, legacyOptions) {
+    debug('init');
+    const options = (0, options_adapter_1.legacyOptionsAdapter)(legacyContext, legacyOptions);
+    const proxyMiddleware = (0, factory_1.createProxyMiddleware)(options);
+    // https://github.com/chimurai/http-proxy-middleware/pull/731/files#diff-07e6ad10bda0df091b737caed42767657cd0bd74a01246a1a0b7ab59c0f6e977L118
+    debug('add marker for patching req.url (old behavior)');
+    proxyMiddleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__ = true;
+    return proxyMiddleware;
+}

datav/node_modules/http-proxy-middleware/dist/legacy/index.d.ts

@@ -0,0 +1 @@
+export * from './public';

datav/node_modules/http-proxy-middleware/dist/legacy/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./public"), exports);

datav/node_modules/http-proxy-middleware/dist/legacy/options-adapter.d.ts

@@ -0,0 +1,6 @@
+import { Filter, Options } from '../types';
+import { LegacyOptions } from './types';
+/**
+ * Convert {@link LegacyOptions legacy Options} to new {@link Options}
+ */
+export declare function legacyOptionsAdapter<TReq, TRes>(legacyContext: Filter<TReq> | LegacyOptions<TReq, TRes>, legacyOptions: LegacyOptions<TReq, TRes>): Options<TReq, TRes>;

datav/node_modules/http-proxy-middleware/dist/legacy/options-adapter.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyOptionsAdapter = legacyOptionsAdapter;
+const url = require("url");
+const debug_1 = require("../debug");
+const logger_1 = require("../logger");
+const debug = debug_1.Debug.extend('legacy-options-adapter');
+// https://github.com/chimurai/http-proxy-middleware/blob/7341704d0aa9d1606dfd37ebfdffddd34c894784/src/_handlers.ts#L20-L27
+const proxyEventMap = {
+    onError: 'error',
+    onProxyReq: 'proxyReq',
+    onProxyRes: 'proxyRes',
+    onProxyReqWs: 'proxyReqWs',
+    onOpen: 'open',
+    onClose: 'close',
+};
+/**
+ * Convert {@link LegacyOptions legacy Options} to new {@link Options}
+ */
+function legacyOptionsAdapter(legacyContext, legacyOptions) {
+    let options = {};
+    let logger;
+    // https://github.com/chimurai/http-proxy-middleware/pull/716
+    if (typeof legacyContext === 'string' && !!url.parse(legacyContext).host) {
+        throw new Error(`Shorthand syntax is removed from legacyCreateProxyMiddleware().
+      Please use "legacyCreateProxyMiddleware({ target: 'http://www.example.org' })" instead.
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-shorthand-usage
+      `);
+    }
+    // detect old "context" argument and convert to "options.pathFilter"
+    // https://github.com/chimurai/http-proxy-middleware/pull/722/files#diff-a2a171449d862fe29692ce031981047d7ab755ae7f84c707aef80701b3ea0c80L4
+    if (legacyContext && legacyOptions) {
+        debug('map legacy context/filter to options.pathFilter');
+        options = { ...legacyOptions, pathFilter: legacyContext };
+        logger = getLegacyLogger(options);
+        logger.warn(`[http-proxy-middleware] Legacy "context" argument is deprecated. Migrate your "context" to "options.pathFilter":
+
+      const options = {
+        pathFilter: '${legacyContext}',
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-context-argument
+      `);
+    }
+    else if (legacyContext && !legacyOptions) {
+        options = { ...legacyContext };
+        logger = getLegacyLogger(options);
+    }
+    else {
+        logger = getLegacyLogger({});
+    }
+    // map old event names to new event names
+    // https://github.com/chimurai/http-proxy-middleware/pull/745/files#diff-c54113cf61ec99691748a3890bfbeb00e10efb3f0a76f03a0fd9ec49072e410aL48-L53
+    Object.entries(proxyEventMap).forEach(([legacyEventName, proxyEventName]) => {
+        if (options[legacyEventName]) {
+            options.on = { ...options.on };
+            options.on[proxyEventName] = options[legacyEventName];
+            debug('map legacy event "%s" to "on.%s"', legacyEventName, proxyEventName);
+            logger.warn(`[http-proxy-middleware] Legacy "${legacyEventName}" is deprecated. Migrate to "options.on.${proxyEventName}":
+
+        const options = {
+          on: {
+            ${proxyEventName}: () => {},
+          },
+        }
+
+        More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#refactored-proxy-events
+        `);
+        }
+    });
+    // map old logProvider to new logger
+    // https://github.com/chimurai/http-proxy-middleware/pull/749
+    const logProvider = options.logProvider && options.logProvider();
+    const logLevel = options.logLevel;
+    debug('legacy logLevel', logLevel);
+    debug('legacy logProvider: %O', logProvider);
+    if (typeof logLevel === 'string' && logLevel !== 'silent') {
+        debug('map "logProvider" to "logger"');
+        logger.warn(`[http-proxy-middleware] Legacy "logLevel" and "logProvider" are deprecated. Migrate to "options.logger":
+
+      const options = {
+        logger: console,
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-logprovider-and-loglevel-options
+      `);
+    }
+    return options;
+}
+function getLegacyLogger(options) {
+    const legacyLogger = options.logProvider && options.logProvider();
+    if (legacyLogger) {
+        options.logger = legacyLogger;
+    }
+    return (0, logger_1.getLogger)(options);
+}

datav/node_modules/http-proxy-middleware/dist/legacy/public.d.ts

@@ -0,0 +1,2 @@
+export { legacyCreateProxyMiddleware } from './create-proxy-middleware';
+export { LegacyOptions } from './types';

datav/node_modules/http-proxy-middleware/dist/legacy/public.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyCreateProxyMiddleware = void 0;
+var create_proxy_middleware_1 = require("./create-proxy-middleware");
+Object.defineProperty(exports, "legacyCreateProxyMiddleware", { enumerable: true, get: function () { return create_proxy_middleware_1.legacyCreateProxyMiddleware; } });

datav/node_modules/http-proxy-middleware/dist/legacy/types.d.ts

@@ -0,0 +1,111 @@
+import type * as http from 'http';
+import { Options } from '../types';
+/**
+ * @deprecated
+ *
+ * Will be removed in a future version.
+ */
+export interface LegacyOptions<TReq = http.IncomingMessage, TRes = http.ServerResponse> extends Options<TReq, TRes> {
+    /**
+     * @deprecated
+     * Use `on.error` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    error: () => {}
+     * }
+     * ```
+     */
+    onError?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyRes` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyRes: () => {}
+     * }
+     * ```
+     */
+    onProxyRes?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyReq` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyReq: () => {}
+     * }
+     * ```
+     */
+    onProxyReq?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyReqWs` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyReqWs: () => {}
+     * }
+     * ```
+     */
+    onProxyReqWs?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.open` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    open: () => {}
+     * }
+     * ```
+     */
+    onOpen?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.close` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    close: () => {}
+     * }
+     * ```
+     */
+    onClose?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `logger` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *  logger: console
+     * }
+     * ```
+     */
+    logProvider?: any;
+    /**
+     * @deprecated
+     * Use `logger` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *  logger: console
+     * }
+     * ```
+     */
+    logLevel?: any;
+}

datav/node_modules/http-proxy-middleware/dist/legacy/types.js

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