@uniformdev/next-app-router 20.81.0 → 20.81.1-alpha.7.sha-91a5b13e0c

package/dist/composition-BvOM-LIW.d.mts

@@ -0,0 +1,28 @@
+import { RouteGetResponseEdgehancedComposition, RouteGetResponseRedirect } from '@uniformdev/canvas';
+import { PageState } from '@uniformdev/next-app-router-shared';
+
+/**
+ * A composition resolved for a page, with the page state it was resolved for. `UniformComposition`
+ * renders it, and the same object can be reused by `generateMetadata`, layouts, or another
+ * resolver that should carry the page state through.
+ */
+type ResolvedComposition = {
+    pageState: PageState;
+    route: RouteGetResponseEdgehancedComposition;
+};
+/** A route that matched a redirect, with the page state it was resolved for. */
+type ResolvedRedirect = {
+    pageState: PageState;
+    route: RouteGetResponseRedirect;
+};
+/**
+ * What a resolver returns: a {@link ResolvedComposition}, a {@link ResolvedRedirect}, or the page
+ * state with no `route` when nothing matched. `requireComposition` handles the redirect and not
+ * found cases with Next.js navigation; `route.type` narrows it for custom handling.
+ */
+type ResolvedRouteResult = ResolvedComposition | ResolvedRedirect | {
+    pageState: PageState;
+    route: undefined;
+};
+
+export type { ResolvedRouteResult as R, ResolvedComposition as a, ResolvedRedirect as b };

package/dist/composition-BvOM-LIW.d.ts

@@ -0,0 +1,28 @@
+import { RouteGetResponseEdgehancedComposition, RouteGetResponseRedirect } from '@uniformdev/canvas';
+import { PageState } from '@uniformdev/next-app-router-shared';
+
+/**
+ * A composition resolved for a page, with the page state it was resolved for. `UniformComposition`
+ * renders it, and the same object can be reused by `generateMetadata`, layouts, or another
+ * resolver that should carry the page state through.
+ */
+type ResolvedComposition = {
+    pageState: PageState;
+    route: RouteGetResponseEdgehancedComposition;
+};
+/** A route that matched a redirect, with the page state it was resolved for. */
+type ResolvedRedirect = {
+    pageState: PageState;
+    route: RouteGetResponseRedirect;
+};
+/**
+ * What a resolver returns: a {@link ResolvedComposition}, a {@link ResolvedRedirect}, or the page
+ * state with no `route` when nothing matched. `requireComposition` handles the redirect and not
+ * found cases with Next.js navigation; `route.type` narrows it for custom handling.
+ */
+type ResolvedRouteResult = ResolvedComposition | ResolvedRedirect | {
+    pageState: PageState;
+    route: undefined;
+};
+
+export type { ResolvedRouteResult as R, ResolvedComposition as a, ResolvedRedirect as b };

package/dist/config/default.js

@@ -26,7 +26,6 @@ module.exports = __toCommonJS(default_exports);
 var config = {
   defaultConsent: true,
   quirkSerialization: true,
-  middlewareRuntimeCache: true,
   playgroundPath: "/uniform/playground"
 };
 var default_default = config;

package/dist/config/default.mjs

@@ -2,7 +2,6 @@
 var config = {
   defaultConsent: true,
   quirkSerialization: true,
-  middlewareRuntimeCache: true,
   playgroundPath: "/uniform/playground"
 };
 var default_default = config;

package/dist/createCachedManifestProvider-C7faGJJ8.d.mts

@@ -0,0 +1,69 @@
+import { ManifestV2 } from '@uniformdev/context';
+
+type ManifestProviderOptions = {
+    /**
+     * Extends the request's lifetime until the promise settles, for work like writing the manifest
+     * to a cache after the response is sent. The edge middleware passes the proxy's
+     * `event.waitUntil`.
+     */
+    waitUntil: (promise: Promise<unknown>) => void;
+};
+/**
+ * Loads the Context manifest the edge middleware chooses variants with. Called once per HTML
+ * document request. Resolves to the manifest or throws.
+ */
+type ManifestProvider = (options: ManifestProviderOptions) => Promise<ManifestV2>;
+/**
+ * A platform's shared cache, which a cached manifest provider stores the manifest in between
+ * instances. Vercel's runtime cache from `getCache()` in `@vercel/functions` matches this shape.
+ */
+type ManifestCache = {
+    /** Resolves to the stored value, or `null` or `undefined` when there is none. */
+    get: (key: string) => Promise<unknown>;
+    set: (key: string, value: ManifestV2, options: {
+        ttl: number;
+        tags: string[];
+    }) => Promise<void>;
+};
+
+type CreateCachedManifestProviderOptions = {
+    /**
+     * The platform's shared cache. Without one, each instance loads the manifest from the API
+     * whenever its copy is older than `maxAge`.
+     */
+    cache?: ManifestCache;
+    /**
+     * Returned when the manifest cannot be loaded and the instance has no earlier copy, for
+     * example a manifest baked into the build with `uniform context manifest download`.
+     */
+    fallback?: ManifestV2;
+    /**
+     * Seconds an entry lives in `cache`. Publishing the manifest expires it sooner when the
+     * preview route handler expires the `manifest` tag in the same cache.
+     *
+     * @defaultValue 3600
+     */
+    ttl?: number;
+    /**
+     * Seconds an instance reuses the manifest it loaded before checking `cache` again. Bounds how
+     * long an instance keeps serving a manifest after it is published.
+     *
+     * @defaultValue 10
+     */
+    maxAge?: number;
+    /**
+     * Loads the published manifest when `cache` has none.
+     *
+     * @defaultValue the Uniform API, with the project and key from the `UNIFORM_*` env vars
+     */
+    fetchManifest?: () => Promise<ManifestV2>;
+};
+/**
+ * Creates a manifest provider that keeps the manifest in memory for `maxAge`, then reads it from
+ * the platform's shared `cache`, then from the Uniform API, writing what it fetched back to the
+ * cache. Concurrent requests share one load. When loading fails, it returns the last manifest it
+ * loaded, then `fallback`, and otherwise rethrows.
+ */
+declare const createCachedManifestProvider: ({ cache, fallback, ttl, maxAge, fetchManifest, }?: CreateCachedManifestProviderOptions) => ManifestProvider;
+
+export { type CreateCachedManifestProviderOptions as C, type ManifestProvider as M, type ManifestProviderOptions as a, type ManifestCache as b, createCachedManifestProvider as c };

package/dist/createCachedManifestProvider-C7faGJJ8.d.ts

@@ -0,0 +1,69 @@
+import { ManifestV2 } from '@uniformdev/context';
+
+type ManifestProviderOptions = {
+    /**
+     * Extends the request's lifetime until the promise settles, for work like writing the manifest
+     * to a cache after the response is sent. The edge middleware passes the proxy's
+     * `event.waitUntil`.
+     */
+    waitUntil: (promise: Promise<unknown>) => void;
+};
+/**
+ * Loads the Context manifest the edge middleware chooses variants with. Called once per HTML
+ * document request. Resolves to the manifest or throws.
+ */
+type ManifestProvider = (options: ManifestProviderOptions) => Promise<ManifestV2>;
+/**
+ * A platform's shared cache, which a cached manifest provider stores the manifest in between
+ * instances. Vercel's runtime cache from `getCache()` in `@vercel/functions` matches this shape.
+ */
+type ManifestCache = {
+    /** Resolves to the stored value, or `null` or `undefined` when there is none. */
+    get: (key: string) => Promise<unknown>;
+    set: (key: string, value: ManifestV2, options: {
+        ttl: number;
+        tags: string[];
+    }) => Promise<void>;
+};
+
+type CreateCachedManifestProviderOptions = {
+    /**
+     * The platform's shared cache. Without one, each instance loads the manifest from the API
+     * whenever its copy is older than `maxAge`.
+     */
+    cache?: ManifestCache;
+    /**
+     * Returned when the manifest cannot be loaded and the instance has no earlier copy, for
+     * example a manifest baked into the build with `uniform context manifest download`.
+     */
+    fallback?: ManifestV2;
+    /**
+     * Seconds an entry lives in `cache`. Publishing the manifest expires it sooner when the
+     * preview route handler expires the `manifest` tag in the same cache.
+     *
+     * @defaultValue 3600
+     */
+    ttl?: number;
+    /**
+     * Seconds an instance reuses the manifest it loaded before checking `cache` again. Bounds how
+     * long an instance keeps serving a manifest after it is published.
+     *
+     * @defaultValue 10
+     */
+    maxAge?: number;
+    /**
+     * Loads the published manifest when `cache` has none.
+     *
+     * @defaultValue the Uniform API, with the project and key from the `UNIFORM_*` env vars
+     */
+    fetchManifest?: () => Promise<ManifestV2>;
+};
+/**
+ * Creates a manifest provider that keeps the manifest in memory for `maxAge`, then reads it from
+ * the platform's shared `cache`, then from the Uniform API, writing what it fetched back to the
+ * cache. Concurrent requests share one load. When loading fails, it returns the last manifest it
+ * loaded, then `fallback`, and otherwise rethrows.
+ */
+declare const createCachedManifestProvider: ({ cache, fallback, ttl, maxAge, fetchManifest, }?: CreateCachedManifestProviderOptions) => ManifestProvider;
+
+export { type CreateCachedManifestProviderOptions as C, type ManifestProvider as M, type ManifestProviderOptions as a, type ManifestCache as b, createCachedManifestProvider as c };

package/dist/edge.d.mts

@@ -0,0 +1,57 @@
+import { ManifestV2 } from '@uniformdev/context';
+import { TransformEdgeStreamOptions } from '@uniformdev/context-edge';
+import { NextRequest, NextFetchEvent } from 'next/server';
+import { M as ManifestProvider, a as ManifestProviderOptions } from './createCachedManifestProvider-C7faGJJ8.mjs';
+export { C as CreateCachedManifestProviderOptions, b as ManifestCache, c as createCachedManifestProvider } from './createCachedManifestProvider-C7faGJJ8.mjs';
+import { HandleOptions } from './middleware.mjs';
+import '@uniformdev/next-app-router-shared';
+
+/**
+ * Marks the edge middleware's own fetch of the rendered page, so the middleware lets it through
+ * when the matcher also covers the rewrite destination.
+ */
+declare const UNIFORM_EDGE_ORIGIN_HEADER = "x-uniform-edge-origin";
+type UniformEdgeMiddlewareOptions = HandleOptions & {
+    /**
+     * The project's Context manifest, which chooses the visitor's variants.
+     *
+     * Pass a manifest baked into the build (for example with `uniform context manifest download`)
+     * so the middleware makes no network calls. Signals and tests published after the build are
+     * then out of date at the edge until the next build.
+     *
+     * Pass a provider, such as `vercelManifestProvider` from `@uniformdev/next-app-router/vercel`
+     * or one made with `createCachedManifestProvider`, to load the published manifest at runtime.
+     * It is called for HTML document requests only, alongside the fetch of the page.
+     */
+    manifest: ManifestV2 | ManifestProvider;
+    /**
+     * Called when the manifest provider throws, and when the NESI transform fails. A provider
+     * failure receives the error, and the edge chooses with an empty manifest: personalizations
+     * show their defaults, and the browser chooses tests after hydration. A transform failure
+     * also receives the decoded HTML chunk that triggered it, when available, and the response
+     * ends at the point of failure.
+     */
+    onError?: TransformEdgeStreamOptions['onError'];
+};
+/**
+ * Returns middleware that rewrites each request to its Uniform code like `uniformMiddleware`, and
+ * processes the NESI tags in the page at the edge. HTML document requests fetch the page rendered
+ * for the route's code and keep only the visitor's variants from the tags it contains, which
+ * `UniformComposition` renders for published personalizations and tests when `edgeMode` is enabled
+ * in `uniform.server.config`. Client navigations, prefetches and draft requests are rewritten, and
+ * their variants are chosen in the browser.
+ *
+ * Requires the optional peer dependency `@uniformdev/context-edge`.
+ */
+declare const uniformEdgeMiddleware: (options: UniformEdgeMiddlewareOptions) => (request: NextRequest, event?: Pick<NextFetchEvent, "waitUntil">) => Promise<Response>;
+/**
+ * Handles one request the way {@link uniformEdgeMiddleware} does. The transformed response is
+ * personalized, so it is marked `private, no-store`. `waitUntil` is handed to a manifest provider
+ * for background work, and defaults to letting the promise run unobserved.
+ */
+declare const handleUniformEdgeRoute: ({ request, manifest, onError, waitUntil, ...options }: UniformEdgeMiddlewareOptions & {
+    request: NextRequest;
+    waitUntil?: ManifestProviderOptions["waitUntil"];
+}) => Promise<Response>;
+
+export { ManifestProvider, ManifestProviderOptions, UNIFORM_EDGE_ORIGIN_HEADER, type UniformEdgeMiddlewareOptions, handleUniformEdgeRoute, uniformEdgeMiddleware };

package/dist/edge.d.ts

@@ -0,0 +1,57 @@
+import { ManifestV2 } from '@uniformdev/context';
+import { TransformEdgeStreamOptions } from '@uniformdev/context-edge';
+import { NextRequest, NextFetchEvent } from 'next/server';
+import { M as ManifestProvider, a as ManifestProviderOptions } from './createCachedManifestProvider-C7faGJJ8.js';
+export { C as CreateCachedManifestProviderOptions, b as ManifestCache, c as createCachedManifestProvider } from './createCachedManifestProvider-C7faGJJ8.js';
+import { HandleOptions } from './middleware.js';
+import '@uniformdev/next-app-router-shared';
+
+/**
+ * Marks the edge middleware's own fetch of the rendered page, so the middleware lets it through
+ * when the matcher also covers the rewrite destination.
+ */
+declare const UNIFORM_EDGE_ORIGIN_HEADER = "x-uniform-edge-origin";
+type UniformEdgeMiddlewareOptions = HandleOptions & {
+    /**
+     * The project's Context manifest, which chooses the visitor's variants.
+     *
+     * Pass a manifest baked into the build (for example with `uniform context manifest download`)
+     * so the middleware makes no network calls. Signals and tests published after the build are
+     * then out of date at the edge until the next build.
+     *
+     * Pass a provider, such as `vercelManifestProvider` from `@uniformdev/next-app-router/vercel`
+     * or one made with `createCachedManifestProvider`, to load the published manifest at runtime.
+     * It is called for HTML document requests only, alongside the fetch of the page.
+     */
+    manifest: ManifestV2 | ManifestProvider;
+    /**
+     * Called when the manifest provider throws, and when the NESI transform fails. A provider
+     * failure receives the error, and the edge chooses with an empty manifest: personalizations
+     * show their defaults, and the browser chooses tests after hydration. A transform failure
+     * also receives the decoded HTML chunk that triggered it, when available, and the response
+     * ends at the point of failure.
+     */
+    onError?: TransformEdgeStreamOptions['onError'];
+};
+/**
+ * Returns middleware that rewrites each request to its Uniform code like `uniformMiddleware`, and
+ * processes the NESI tags in the page at the edge. HTML document requests fetch the page rendered
+ * for the route's code and keep only the visitor's variants from the tags it contains, which
+ * `UniformComposition` renders for published personalizations and tests when `edgeMode` is enabled
+ * in `uniform.server.config`. Client navigations, prefetches and draft requests are rewritten, and
+ * their variants are chosen in the browser.
+ *
+ * Requires the optional peer dependency `@uniformdev/context-edge`.
+ */
+declare const uniformEdgeMiddleware: (options: UniformEdgeMiddlewareOptions) => (request: NextRequest, event?: Pick<NextFetchEvent, "waitUntil">) => Promise<Response>;
+/**
+ * Handles one request the way {@link uniformEdgeMiddleware} does. The transformed response is
+ * personalized, so it is marked `private, no-store`. `waitUntil` is handed to a manifest provider
+ * for background work, and defaults to letting the promise run unobserved.
+ */
+declare const handleUniformEdgeRoute: ({ request, manifest, onError, waitUntil, ...options }: UniformEdgeMiddlewareOptions & {
+    request: NextRequest;
+    waitUntil?: ManifestProviderOptions["waitUntil"];
+}) => Promise<Response>;
+
+export { ManifestProvider, ManifestProviderOptions, UNIFORM_EDGE_ORIGIN_HEADER, type UniformEdgeMiddlewareOptions, handleUniformEdgeRoute, uniformEdgeMiddleware };