@koine/next 2.0.0-beta.2 → 2.0.0-beta.21

package/config-i18n.js

@@ -0,0 +1,251 @@
+import { __assign, __awaiter, __generator } from "tslib";
+var arrayUniqueByProperties = function (array, keys) {
+    return array.filter(function (item, idx, arr) {
+        return arr.findIndex(function (itemWith) {
+            return keys.every(function (k) { return itemWith[k] === item[k]; });
+        }) === idx;
+    });
+};
+export function normaliseUrlPathname(pathname) {
+    if (pathname === void 0) { pathname = ""; }
+    return pathname.replace(/\/+\//g, "/").replace(/^\/*(.*?)\/*$/, "$1");
+}
+export function toPath(urlOrPathname) {
+    if (urlOrPathname === void 0) { urlOrPathname = ""; }
+    var pathname = "";
+    try {
+        var parsed = new URL(urlOrPathname);
+        pathname = parsed.pathname;
+    }
+    catch (e) {
+        pathname = urlOrPathname;
+    }
+    return pathname.replace(/\/+\//g, "/").replace(/^\/*(.*?)\/*$/, "$1");
+}
+export function encodePathname(pathname) {
+    if (pathname === void 0) { pathname = ""; }
+    var parts = normaliseUrlPathname(pathname).split("/");
+    return parts
+        .filter(function (part) { return !!part; })
+        .map(function (part) { return encodeURIComponent(part); })
+        .join("/");
+}
+function transformRoute(route) {
+    var rawPathname = route.pathname, rawTemplate = route.template;
+    var pathnameParts = rawPathname.split("/").filter(function (part) { return !!part; });
+    var templateParts = rawTemplate.split("/").filter(function (part) { return !!part; });
+    var mapPartsByIdx = {};
+    var pathname = pathnameParts
+        .map(function (part) {
+        var _a, _b;
+        var hasWildcard = part.endsWith("*");
+        part = part.replace("*", "");
+        var isDynamic = part.startsWith("{{") && part.endsWith("}}");
+        var asValue = isDynamic
+            ? (_b = (_a = part.match(/{{(.+)}}/)) === null || _a === void 0 ? void 0 : _a[1].trim()) !== null && _b !== void 0 ? _b : ""
+            : part.trim();
+        var asPath = encodeURIComponent(asValue) + (hasWildcard ? "*" : "");
+        mapPartsByIdx[asValue] = {
+            isDynamic: isDynamic,
+            hasWildcard: hasWildcard,
+        };
+        return isDynamic ? ":".concat(asPath) : asPath;
+    })
+        .join("/");
+    var template = templateParts
+        .map(function (part) {
+        var _a, _b, _c;
+        var isDynamic = part.startsWith("[") && part.endsWith("]");
+        var asValue = isDynamic
+            ? (_b = (_a = part.match(/\[(.+)\]/)) === null || _a === void 0 ? void 0 : _a[1].trim()) !== null && _b !== void 0 ? _b : ""
+            : part.trim();
+        var hasWildcard = (_c = mapPartsByIdx[asValue]) === null || _c === void 0 ? void 0 : _c.hasWildcard;
+        var asPath = encodeURIComponent(asValue) + (hasWildcard ? "*" : "");
+        return isDynamic ? ":".concat(asPath) : asPath;
+    })
+        .join("/");
+    return { pathname: pathname, template: template };
+}
+function getRoutesMap(map, routesByLocale, pathnameBuffer, templateBuffer) {
+    if (map === void 0) { map = {}; }
+    if (pathnameBuffer === void 0) { pathnameBuffer = ""; }
+    if (templateBuffer === void 0) { templateBuffer = ""; }
+    var isSpaRoute = Object.keys(routesByLocale).includes("[spa]");
+    for (var key in routesByLocale) {
+        var pathOrNestedRoutes = routesByLocale[key];
+        var template = "".concat(templateBuffer, "/").concat(key);
+        if (typeof pathOrNestedRoutes === "string") {
+            if (!isSpaRoute || (isSpaRoute && ["[spa]", "index"].includes(key))) {
+                map[template] = {
+                    template: template,
+                    pathname: pathOrNestedRoutes,
+                    wildcard: pathOrNestedRoutes.includes("*"),
+                };
+            }
+        }
+        else {
+            if (!isSpaRoute) {
+                getRoutesMap(map, pathOrNestedRoutes, pathnameBuffer, template);
+            }
+        }
+    }
+    return map;
+}
+function getWithoutIndex(template) {
+    return template.replace(/\/index$/, "");
+}
+export function getRoutesOfDefaultLocale(routes, defaultLocale) {
+    var routesByLocale = routes;
+    if (defaultLocale &&
+        routesByLocale[defaultLocale]) {
+        return routesByLocale[defaultLocale];
+    }
+    if (Object.keys(routes).length === 1) {
+        var routesWithOneLocale = routes;
+        var output = {};
+        for (var onlyLocale in routesWithOneLocale) {
+            output =
+                routesWithOneLocale[onlyLocale];
+        }
+        return output;
+    }
+    return routes;
+}
+export function getPathRedirect(arg) {
+    var localeSource = arg.localeSource, localeDestination = arg.localeDestination, route = arg.route, usePathnameAsSource = arg.usePathnameAsSource, permanent = arg.permanent;
+    var _a = transformRoute(route), routeTemplate = _a.template, pathname = _a.pathname;
+    var template = usePathnameAsSource ? pathname : routeTemplate;
+    var sourcePrefix = localeSource ? "".concat(localeSource, "/") : "";
+    var source = getWithoutIndex("/".concat(normaliseUrlPathname(sourcePrefix + template)));
+    var destinationPrefix = localeDestination ? "".concat(localeDestination, "/") : "";
+    var destination = "/".concat(normaliseUrlPathname(destinationPrefix + pathname));
+    if (source === destination)
+        return;
+    var redirect = {
+        source: source,
+        destination: destination,
+        permanent: Boolean(permanent),
+    };
+    return redirect;
+}
+export function getRedirects(arg) {
+    return __awaiter(this, void 0, void 0, function () {
+        var routes, defaultLocale, hideDefaultLocaleInUrl, localeParam, permanent, debug, redirects, locale, routesByLocale, routesMap, template, route, isVisibleDefaultLocale, isHiddenDefaultLocale, cleaned;
+        return __generator(this, function (_a) {
+            routes = arg.routes, defaultLocale = arg.defaultLocale, hideDefaultLocaleInUrl = arg.hideDefaultLocaleInUrl, localeParam = arg.localeParam, permanent = arg.permanent, debug = arg.debug;
+            redirects = [];
+            for (locale in routes) {
+                routesByLocale = routes[locale];
+                routesMap = getRoutesMap({}, routesByLocale);
+                for (template in routesMap) {
+                    route = routesMap[template];
+                    if (route.pathname !== getWithoutIndex(template)) {
+                        isVisibleDefaultLocale = locale === defaultLocale && !hideDefaultLocaleInUrl;
+                        isHiddenDefaultLocale = locale === defaultLocale && hideDefaultLocaleInUrl;
+                        if (localeParam) {
+                            if (isVisibleDefaultLocale) {
+                                redirects.push(getPathRedirect({ localeDestination: locale, route: route, permanent: permanent }));
+                            }
+                            else if (isHiddenDefaultLocale) {
+                                redirects.push(getPathRedirect({ localeSource: locale, route: route, permanent: permanent }));
+                            }
+                            else if (locale !== defaultLocale) {
+                                redirects.push(getPathRedirect({
+                                    localeSource: locale,
+                                    localeDestination: locale,
+                                    route: route,
+                                    permanent: permanent,
+                                }));
+                            }
+                            else {
+                                redirects.push(getPathRedirect({ route: route, permanent: permanent }));
+                            }
+                        }
+                        else {
+                            if (isVisibleDefaultLocale) {
+                                redirects.push(getPathRedirect({ localeDestination: locale, route: route, permanent: permanent }));
+                            }
+                            else if (locale !== defaultLocale) {
+                                redirects.push(getPathRedirect({
+                                    localeSource: locale,
+                                    localeDestination: locale,
+                                    route: route,
+                                    permanent: permanent,
+                                }));
+                            }
+                            else {
+                                redirects.push(getPathRedirect({ route: route, permanent: permanent }));
+                            }
+                        }
+                    }
+                }
+            }
+            cleaned = arrayUniqueByProperties(redirects.filter(Boolean), ["source", "destination"]).map(function (rewrite) { return (localeParam ? rewrite : __assign(__assign({}, rewrite), { locale: false })); });
+            if (debug)
+                console.info("[@koine/next/config:getRedirects]", cleaned);
+            return [2, cleaned];
+        });
+    });
+}
+export function getPathRewrite(arg) {
+    var localeSource = arg.localeSource, localeDestination = arg.localeDestination, localeParam = arg.localeParam, route = arg.route;
+    var _a = transformRoute(route), pathname = _a.pathname, template = _a.template;
+    var sourcePrefix = "";
+    if (localeSource)
+        sourcePrefix = "".concat(localeSource, "/");
+    else if (localeParam)
+        sourcePrefix = ":".concat(localeParam, "/");
+    var source = "/".concat(normaliseUrlPathname(sourcePrefix + pathname));
+    var destinationPrefix = "";
+    if (localeDestination)
+        destinationPrefix = "".concat(localeDestination, "/");
+    else if (localeParam)
+        destinationPrefix = ":".concat(localeParam, "/");
+    var destination = getWithoutIndex("/".concat(normaliseUrlPathname(destinationPrefix + template)));
+    if (source === destination)
+        return;
+    return {
+        source: source,
+        destination: destination,
+    };
+}
+export function getRewrites(arg) {
+    return __awaiter(this, void 0, void 0, function () {
+        var routes, defaultLocale, hideDefaultLocaleInUrl, localeParam, debug, rewrites, locale, routesByLocale, routesMap, template, route, isVisibleDefaultLocale, isHiddenDefaultLocale, cleaned;
+        return __generator(this, function (_a) {
+            routes = arg.routes, defaultLocale = arg.defaultLocale, hideDefaultLocaleInUrl = arg.hideDefaultLocaleInUrl, localeParam = arg.localeParam, debug = arg.debug;
+            rewrites = [];
+            for (locale in routes) {
+                routesByLocale = routes[locale];
+                routesMap = getRoutesMap({}, routesByLocale);
+                for (template in routesMap) {
+                    route = routesMap[template];
+                    isVisibleDefaultLocale = locale === defaultLocale && !hideDefaultLocaleInUrl;
+                    isHiddenDefaultLocale = locale === defaultLocale && hideDefaultLocaleInUrl;
+                    if (localeParam) {
+                        if (isHiddenDefaultLocale) {
+                            rewrites.push(getPathRewrite({ localeDestination: locale, route: route }));
+                        }
+                        else {
+                            rewrites.push(getPathRewrite({ localeParam: localeParam, route: route }));
+                        }
+                    }
+                    else {
+                        if (route.pathname !== getWithoutIndex(template)) {
+                            if (locale !== defaultLocale || isVisibleDefaultLocale) {
+                                rewrites.push(getPathRewrite({ localeSource: locale, route: route }));
+                            }
+                            else {
+                                rewrites.push(getPathRewrite({ route: route }));
+                            }
+                        }
+                    }
+                }
+            }
+            cleaned = arrayUniqueByProperties(rewrites.filter(Boolean), ["source", "destination"]);
+            if (debug)
+                console.info("[@koine/next/config:getRewrites]", cleaned);
+            return [2, cleaned];
+        });
+    });
+}

package/config.d.ts

@@ -0,0 +1,109 @@
+import type { NextConfig } from "next";
+import { type ConfigI18nOptions, type Routes } from "./config-i18n.js";
+interface KoineNextConfig {
+    nx?: boolean;
+    svg?: boolean;
+    sc?: boolean;
+    page?: boolean;
+    routes?: Routes;
+    permanent?: boolean;
+    debug?: boolean;
+    i18n: ConfigI18nOptions & {
+        loader?: any;
+    };
+}
+interface MergedConfig extends KoineNextConfig, Omit<NextConfig, "i18n"> {
+}
+export declare function withKoine({ nx, svg, sc, page, routes, permanent, debug, ...custom }?: MergedConfig): NextConfig | {
+    redirects(): Promise<import("./config-i18n.js").Redirect[]>;
+    rewrites(): Promise<{
+        beforeFiles: import("./config-i18n.js").Rewrite[];
+        afterFiles: import("next/dist/lib/load-custom-routes.js").Rewrite[];
+        fallback: import("next/dist/lib/load-custom-routes.js").Rewrite[];
+    }>;
+    exportPathMap?: ((defaultMap: import("next/dist/server/config-shared.js").ExportPathMap, ctx: {
+        dev: boolean;
+        dir: string;
+        outDir: string | null;
+        distDir: string;
+        buildId: string;
+    }) => import("next/dist/server/config-shared.js").ExportPathMap | Promise<import("next/dist/server/config-shared.js").ExportPathMap>) | undefined;
+    i18n?: import("next/dist/server/config-shared.js").I18NConfig | null | undefined;
+    eslint?: import("next/dist/server/config-shared.js").ESLintConfig | undefined;
+    typescript?: import("next/dist/server/config-shared.js").TypeScriptConfig | undefined;
+    headers?: (() => Promise<import("next/dist/lib/load-custom-routes.js").Header[]>) | undefined;
+    excludeDefaultMomentLocales?: boolean | undefined;
+    webpack?: import("next/dist/server/config-shared.js").NextJsWebpackConfig | null | undefined;
+    trailingSlash?: boolean | undefined;
+    env?: Record<string, string> | undefined;
+    distDir?: string | undefined;
+    cleanDistDir?: boolean | undefined;
+    assetPrefix?: string | undefined;
+    useFileSystemPublicRoutes?: boolean | undefined;
+    generateBuildId?: (() => string | Promise<string | null> | null) | undefined;
+    generateEtags?: boolean | undefined;
+    pageExtensions?: string[] | undefined;
+    compress?: boolean | undefined;
+    analyticsId?: string | undefined;
+    poweredByHeader?: boolean | undefined;
+    images?: Partial<import("next/dist/shared/lib/image-config.js").ImageConfigComplete> | undefined;
+    devIndicators?: {
+        buildActivity?: boolean | undefined;
+        buildActivityPosition?: "bottom-right" | "bottom-left" | "top-right" | "top-left" | undefined;
+    } | undefined;
+    onDemandEntries?: {
+        maxInactiveAge?: number | undefined;
+        pagesBufferLength?: number | undefined;
+    } | undefined;
+    amp?: {
+        canonicalBase?: string | undefined;
+    } | undefined;
+    basePath?: string | undefined;
+    sassOptions?: {
+        [key: string]: any;
+    } | undefined;
+    productionBrowserSourceMaps?: boolean | undefined;
+    optimizeFonts?: boolean | undefined;
+    reactProductionProfiling?: boolean | undefined;
+    reactStrictMode?: boolean | null | undefined;
+    publicRuntimeConfig?: {
+        [key: string]: any;
+    } | undefined;
+    serverRuntimeConfig?: {
+        [key: string]: any;
+    } | undefined;
+    httpAgentOptions?: {
+        keepAlive?: boolean | undefined;
+    } | undefined;
+    outputFileTracing?: boolean | undefined;
+    staticPageGenerationTimeout?: number | undefined;
+    crossOrigin?: false | "anonymous" | "use-credentials" | undefined;
+    swcMinify?: boolean | undefined;
+    compiler?: {
+        reactRemoveProperties?: boolean | {
+            properties?: string[] | undefined;
+        } | undefined;
+        relay?: {
+            src: string;
+            artifactDirectory?: string | undefined;
+            language?: "typescript" | "flow" | "javascript" | undefined;
+            eagerEsModules?: boolean | undefined;
+        } | undefined;
+        removeConsole?: boolean | {
+            exclude?: string[] | undefined;
+        } | undefined;
+        styledComponents?: boolean | import("next/dist/server/config-shared.js").StyledComponentsConfig | undefined;
+        emotion?: boolean | import("next/dist/server/config-shared.js").EmotionConfig | undefined;
+    } | undefined;
+    output?: "standalone" | "export" | undefined;
+    transpilePackages?: string[] | undefined;
+    skipMiddlewareUrlNormalize?: boolean | undefined;
+    skipTrailingSlashRedirect?: boolean | undefined;
+    modularizeImports?: Record<string, {
+        transform: string | Record<string, string>;
+        preventFullImport?: boolean | undefined;
+        skipDefaultConversion?: boolean | undefined;
+    }> | undefined;
+    experimental?: import("next/dist/server/config-shared.js").ExperimentalConfig | undefined;
+};
+export default withKoine;

package/config.js

@@ -0,0 +1,118 @@
+import { __assign, __awaiter, __generator, __read, __rest, __spreadArray } from "tslib";
+import { getRedirects, getRewrites, } from "./config-i18n.js";
+export function withKoine(_a) {
+    if (_a === void 0) { _a = {
+        i18n: {
+            locales: ["en"],
+            defaultLocale: "en",
+            hideDefaultLocaleInUrl: false,
+        },
+    }; }
+    var _b = _a.nx, nx = _b === void 0 ? true : _b, _c = _a.svg, svg = _c === void 0 ? true : _c, _d = _a.sc, sc = _d === void 0 ? true : _d, page = _a.page, routes = _a.routes, permanent = _a.permanent, debug = _a.debug, custom = __rest(_a, ["nx", "svg", "sc", "page", "routes", "permanent", "debug"]);
+    var nextConfig = __assign({ pageExtensions: page ? ["page.tsx", "page.ts"] : undefined, eslint: {
+            ignoreDuringBuilds: true,
+        }, typescript: {
+            ignoreBuildErrors: true,
+        }, poweredByHeader: false, swcMinify: true, modularizeImports: __assign({ "@koine/api": { transform: "@koine/api/{{member}}" }, "@koine/browser": { transform: "@koine/browser/{{member}}" }, "@koine/dom": { transform: "@koine/dom/{{member}}" }, "@koine/next/?(((\\w*)?/?)*)": {
+                transform: "@koine/next/{{ matches.[1] }}/{{member}}",
+            }, "@koine/react/?(((\\w*)?/?)*)": {
+                transform: "@koine/react/{{ matches.[1] }}/{{member}}",
+            }, "@koine/utils": { transform: "@koine/utils/{{member}}" } }, (custom["modularizeImports"] || {})), experimental: __assign({ scrollRestoration: true }, (custom["experimental"] || {})) }, custom);
+    if (svg) {
+        if (nx) {
+            nextConfig["nx"] = {
+                svgr: true,
+            };
+        }
+        else {
+            nextConfig.webpack = function (_config, options) {
+                var webpackConfig = typeof nextConfig.webpack === "function"
+                    ? nextConfig.webpack(_config, options)
+                    : _config;
+                webpackConfig.module.rules.push({
+                    test: /\.svg$/,
+                    use: [
+                        {
+                            loader: "@svgr/webpack",
+                            options: {
+                                svgoConfig: {
+                                    plugins: [
+                                        {
+                                            name: "removeViewBox",
+                                            active: false,
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    ],
+                });
+                return webpackConfig;
+            };
+        }
+    }
+    if (sc) {
+        nextConfig.compiler = {
+            styledComponents: true,
+        };
+    }
+    if (custom.i18n) {
+        var _e = custom.i18n || {}, hideDefaultLocaleInUrl = _e.hideDefaultLocaleInUrl, localeParam = _e.localeParam, loader = _e.loader, nextI18nConfig = __rest(_e, ["hideDefaultLocaleInUrl", "localeParam", "loader"]);
+        if (localeParam) {
+            delete nextConfig.i18n;
+        }
+        else {
+            nextConfig.i18n = nextI18nConfig;
+        }
+    }
+    if (routes) {
+        return __assign(__assign({}, nextConfig), { redirects: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var defaults, customs;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4, getRedirects(__assign({ routes: routes, permanent: permanent, debug: debug }, custom.i18n))];
+                            case 1:
+                                defaults = _a.sent();
+                                if (!nextConfig.redirects) return [3, 3];
+                                return [4, nextConfig.redirects()];
+                            case 2:
+                                customs = _a.sent();
+                                return [2, __spreadArray(__spreadArray([], __read(defaults), false), __read(customs), false)];
+                            case 3: return [2, defaults];
+                        }
+                    });
+                });
+            }, rewrites: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var defaults, customs;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4, getRewrites(__assign({ routes: routes, debug: debug }, custom.i18n))];
+                            case 1:
+                                defaults = _a.sent();
+                                if (!nextConfig.rewrites) return [3, 3];
+                                return [4, nextConfig.rewrites()];
+                            case 2:
+                                customs = _a.sent();
+                                if (Array.isArray(customs)) {
+                                    return [2, {
+                                            beforeFiles: defaults,
+                                            afterFiles: customs,
+                                            fallback: [],
+                                        }];
+                                }
+                                return [2, __assign(__assign({}, customs), { beforeFiles: __spreadArray(__spreadArray([], __read(defaults), false), __read((customs.beforeFiles || [])), false) })];
+                            case 3: return [2, {
+                                    afterFiles: [],
+                                    beforeFiles: defaults,
+                                    fallback: [],
+                                }];
+                        }
+                    });
+                });
+            } });
+    }
+    return nextConfig;
+}
+export default withKoine;

package/getSiteUrl.d.ts

@@ -1,8 +1,2 @@
-/**
- * Get site absolute url with the given path
- *
- * - It uses the `NEXT_PUBLIC_APP_URL` env variable
- * - It removes the trailing slashes
- */
 export declare function getSiteUrl(path?: string): string;
 export default getSiteUrl;

package/getSiteUrl.js

@@ -1,17 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSiteUrl = void 0;
-var tslib_1 = require("tslib");
-var normaliseUrl_1 = tslib_1.__importDefault(require("@koine/utils/normaliseUrl"));
-/**
- * Get site absolute url with the given path
- *
- * - It uses the `NEXT_PUBLIC_APP_URL` env variable
- * - It removes the trailing slashes
- */
-function getSiteUrl(path) {
+import { normaliseUrl } from "@koine/utils";
+export function getSiteUrl(path) {
     if (path === void 0) { path = ""; }
-    return (0, normaliseUrl_1.default)("".concat(process.env["NEXT_PUBLIC_APP_URL"], "/").concat(path));
+    return normaliseUrl("".concat(process.env["NEXT_PUBLIC_APP_URL"], "/").concat(path));
 }
-exports.getSiteUrl = getSiteUrl;
-exports.default = getSiteUrl;
+export default getSiteUrl;

package/index.d.ts

@@ -1,2 +1,5 @@
-export { getSiteUrl } from "./getSiteUrl";
-export { load } from "./load";
+export { getSiteUrl } from "./getSiteUrl.js";
+export { load } from "./load.js";
+export { ThemeContext, type ThemeContextProps } from "./ThemeContext.js";
+export { ThemeProvider, type ThemeProviderProps } from "./ThemeProvider.js";
+export { useTheme, type UseThemeProps } from "./useTheme.js";

package/index.js

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.load = exports.getSiteUrl = void 0;
-var getSiteUrl_1 = require("./getSiteUrl");
-Object.defineProperty(exports, "getSiteUrl", { enumerable: true, get: function () { return getSiteUrl_1.getSiteUrl; } });
-var load_1 = require("./load");
-Object.defineProperty(exports, "load", { enumerable: true, get: function () { return load_1.load; } });
+export { getSiteUrl } from "./getSiteUrl.js";
+export { load } from "./load.js";
+export { ThemeContext } from "./ThemeContext.js";
+export { ThemeProvider } from "./ThemeProvider.js";
+export { useTheme } from "./useTheme.js";

package/load.d.ts

@@ -1,10 +1,2 @@
-/**
- * Utility to load a component with an optional pre-determined delay.
- *
- * This was designed to improve anti spam with async form loading.
- *
- * @see https://github.com/vercel/next.js/blob/main/packages/next/next-server/lib/dynamic.tsx
- * @see https://github.com/vercel/next.js/blob/canary/examples/with-dynamic-import/pages/index.js
- */
 export declare function load<T>(component: T, milliseconds: number): Promise<T>;
 export default load;

package/load.js

@@ -1,18 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.load = void 0;
-/**
- * Utility to load a component with an optional pre-determined delay.
- *
- * This was designed to improve anti spam with async form loading.
- *
- * @see https://github.com/vercel/next.js/blob/main/packages/next/next-server/lib/dynamic.tsx
- * @see https://github.com/vercel/next.js/blob/canary/examples/with-dynamic-import/pages/index.js
- */
-function load(component, milliseconds) {
+export function load(component, milliseconds) {
     return new Promise(function (resolve) {
         setTimeout(function () { return resolve(component); }, milliseconds);
     });
 }
-exports.load = load;
-exports.default = load;
+export default load;