"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "EdgeRouteModuleWrapper", {
    enumerable: true,
    get: function() {
        return EdgeRouteModuleWrapper;
    }
});
require("./globals");
const _adapter = require("./adapter");
const _incrementalcache = require("../lib/incremental-cache");
const _routematcher = require("../future/route-matchers/route-matcher");
const _removetrailingslash = require("../../shared/lib/router/utils/remove-trailing-slash");
const _removepathprefix = require("../../shared/lib/router/utils/remove-path-prefix");
class EdgeRouteModuleWrapper {
    /**
   * The constructor is wrapped with private to ensure that it can only be
   * constructed by the static wrap method.
   *
   * @param routeModule the route module to wrap
   */ constructor(routeModule){
        this.routeModule = routeModule;
        // TODO: (wyattjoh) possibly allow the module to define it's own matcher
        this.matcher = new _routematcher.RouteMatcher(routeModule.definition);
    }
    /**
   * This will wrap a module with the EdgeModuleWrapper and return a function
   * that can be used as a handler for the edge runtime.
   *
   * @param module the module to wrap
   * @param options any options that should be passed to the adapter and
   *                override the ones passed from the runtime
   * @returns a function that can be used as a handler for the edge runtime
   */ static wrap(routeModule, options = {}) {
        // Create the module wrapper.
        const wrapper = new EdgeRouteModuleWrapper(routeModule);
        // Return the wrapping function.
        return (opts)=>{
            return (0, _adapter.adapter)({
                ...opts,
                ...options,
                IncrementalCache: _incrementalcache.IncrementalCache,
                // Bind the handler method to the wrapper so it still has context.
                handler: wrapper.handler.bind(wrapper)
            });
        };
    }
    async handler(request) {
        // Get the pathname for the matcher. Pathnames should not have trailing
        // slashes for matching.
        let pathname = (0, _removetrailingslash.removeTrailingSlash)(new URL(request.url).pathname);
        // Get the base path and strip it from the pathname if it exists.
        const { basePath } = request.nextUrl;
        if (basePath) {
            // If the path prefix doesn't exist, then this will do nothing.
            pathname = (0, _removepathprefix.removePathPrefix)(pathname, basePath);
        }
        // Get the match for this request.
        const match = this.matcher.match(pathname);
        if (!match) {
            throw new Error(`Invariant: no match found for request. Pathname '${pathname}' should have matched '${this.matcher.definition.pathname}'`);
        }
        const prerenderManifest = typeof self.__PRERENDER_MANIFEST === "string" ? JSON.parse(self.__PRERENDER_MANIFEST) : undefined;
        // Create the context for the handler. This contains the params from the
        // match (if any).
        const context = {
            params: match.params,
            prerenderManifest: {
                version: 4,
                routes: {},
                dynamicRoutes: {},
                preview: (prerenderManifest == null ? void 0 : prerenderManifest.preview) || {
                    previewModeEncryptionKey: "",
                    previewModeId: "development-id",
                    previewModeSigningKey: ""
                },
                notFoundRoutes: []
            },
            staticGenerationContext: {
                supportsDynamicHTML: true
            }
        };
        // Get the response from the handler.
        return await this.routeModule.handle(request, context);
    }
}

//# sourceMappingURL=edge-route-module-wrapper.js.map