@uniformdev/next-app-router 20.80.2 → 20.81.1-alpha.10.sha-def425616f

package/dist/composition-CGU7iH-k.d.mts

@@ -0,0 +1,37 @@
+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;
+};
+/** Nothing matched, with the page state the resolver ran for. */
+type ResolvedNotFound = {
+    pageState: PageState;
+    route: undefined;
+};
+/**
+ * What `resolveCompositionById`, `resolveCompositionBySlug` and `resolvePlaygroundRoute` return: a
+ * {@link ResolvedComposition}, or {@link ResolvedNotFound} when no composition matched. They skip
+ * the Route API, so they never return a redirect.
+ */
+type ResolvedCompositionResult = ResolvedComposition | ResolvedNotFound;
+/**
+ * What a Route API resolver returns: a {@link ResolvedComposition}, a {@link ResolvedRedirect}, or
+ * {@link ResolvedNotFound} when nothing matched. `UniformComposition` takes it as is and renders
+ * only a composition; `requireComposition` applies the redirect and not found cases with Next.js
+ * navigation.
+ */
+type ResolvedRouteResult = ResolvedComposition | ResolvedRedirect | ResolvedNotFound;
+
+export type { ResolvedCompositionResult as R, ResolvedRouteResult as a, ResolvedComposition as b, ResolvedNotFound as c, ResolvedRedirect as d };

package/dist/composition-CGU7iH-k.d.ts

@@ -0,0 +1,37 @@
+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;
+};
+/** Nothing matched, with the page state the resolver ran for. */
+type ResolvedNotFound = {
+    pageState: PageState;
+    route: undefined;
+};
+/**
+ * What `resolveCompositionById`, `resolveCompositionBySlug` and `resolvePlaygroundRoute` return: a
+ * {@link ResolvedComposition}, or {@link ResolvedNotFound} when no composition matched. They skip
+ * the Route API, so they never return a redirect.
+ */
+type ResolvedCompositionResult = ResolvedComposition | ResolvedNotFound;
+/**
+ * What a Route API resolver returns: a {@link ResolvedComposition}, a {@link ResolvedRedirect}, or
+ * {@link ResolvedNotFound} when nothing matched. `UniformComposition` takes it as is and renders
+ * only a composition; `requireComposition` applies the redirect and not found cases with Next.js
+ * navigation.
+ */
+type ResolvedRouteResult = ResolvedComposition | ResolvedRedirect | ResolvedNotFound;
+
+export type { ResolvedCompositionResult as R, ResolvedRouteResult as a, ResolvedComposition as b, ResolvedNotFound as c, ResolvedRedirect as d };

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-2-2u3PYd.d.mts

@@ -0,0 +1,84 @@
+import { b as EdgeRouteFilterCache, E as EdgeRouteFilter, e as ManifestCache, M as ManifestProvider } from './models-C8OdCO44.mjs';
+import { ManifestV2 } from '@uniformdev/context';
+
+type CreateLearnedEdgeRouteFilterOptions = {
+    /**
+     * The platform's shared cache. Without one, each instance learns on its own and forgets when it
+     * restarts.
+     */
+    cache?: EdgeRouteFilterCache;
+    /**
+     * Seconds a record lives in `cache`. Publishing a composition or changing the project map
+     * expires its paths sooner when the preview route handler expires their `path:` tags in the same
+     * cache.
+     *
+     * @defaultValue 3600
+     */
+    ttl?: number;
+    /**
+     * Seconds an instance reuses what it knows about a page before checking `cache` again. Bounds
+     * how long an instance keeps a record after it is expired.
+     *
+     * @defaultValue 10
+     */
+    maxAge?: number;
+    /**
+     * Pages an instance remembers. The least recently stored page is forgotten first.
+     *
+     * @defaultValue 1000
+     */
+    maxEntries?: number;
+};
+/**
+ * Creates an edge route filter that learns which pages have placements. A page it knows nothing
+ * about is processed, and the edge middleware reports whether the transform found placements.
+ * Pages without placements are then rewritten without processing until the record expires.
+ * Records live in memory for `maxAge`, then in the platform's shared `cache`, tagged with the
+ * page's `path:` tag.
+ *
+ * Publishing a pattern or entry does not expire the pages that use it. Until the record expires,
+ * a page that gained a placement that way has it chosen in the browser.
+ */
+declare const createLearnedEdgeRouteFilter: ({ cache, ttl, maxAge, maxEntries, }?: CreateLearnedEdgeRouteFilterOptions) => EdgeRouteFilter;
+
+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 CreateLearnedEdgeRouteFilterOptions as a, createLearnedEdgeRouteFilter as b, createCachedManifestProvider as c };

package/dist/createCachedManifestProvider-BoorKD15.d.ts

@@ -0,0 +1,84 @@
+import { b as EdgeRouteFilterCache, E as EdgeRouteFilter, e as ManifestCache, M as ManifestProvider } from './models-C8OdCO44.js';
+import { ManifestV2 } from '@uniformdev/context';
+
+type CreateLearnedEdgeRouteFilterOptions = {
+    /**
+     * The platform's shared cache. Without one, each instance learns on its own and forgets when it
+     * restarts.
+     */
+    cache?: EdgeRouteFilterCache;
+    /**
+     * Seconds a record lives in `cache`. Publishing a composition or changing the project map
+     * expires its paths sooner when the preview route handler expires their `path:` tags in the same
+     * cache.
+     *
+     * @defaultValue 3600
+     */
+    ttl?: number;
+    /**
+     * Seconds an instance reuses what it knows about a page before checking `cache` again. Bounds
+     * how long an instance keeps a record after it is expired.
+     *
+     * @defaultValue 10
+     */
+    maxAge?: number;
+    /**
+     * Pages an instance remembers. The least recently stored page is forgotten first.
+     *
+     * @defaultValue 1000
+     */
+    maxEntries?: number;
+};
+/**
+ * Creates an edge route filter that learns which pages have placements. A page it knows nothing
+ * about is processed, and the edge middleware reports whether the transform found placements.
+ * Pages without placements are then rewritten without processing until the record expires.
+ * Records live in memory for `maxAge`, then in the platform's shared `cache`, tagged with the
+ * page's `path:` tag.
+ *
+ * Publishing a pattern or entry does not expire the pages that use it. Until the record expires,
+ * a page that gained a placement that way has it chosen in the browser.
+ */
+declare const createLearnedEdgeRouteFilter: ({ cache, ttl, maxAge, maxEntries, }?: CreateLearnedEdgeRouteFilterOptions) => EdgeRouteFilter;
+
+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 CreateLearnedEdgeRouteFilterOptions as a, createLearnedEdgeRouteFilter as b, createCachedManifestProvider as c };

package/dist/edge.d.mts

@@ -0,0 +1,80 @@
+import { ManifestV2 } from '@uniformdev/context';
+import { TransformEdgeStreamOptions } from '@uniformdev/context-edge';
+import { NextRequest, NextFetchEvent } from 'next/server';
+import { M as ManifestProvider, E as EdgeRouteFilter, a as ManifestProviderOptions } from './models-C8OdCO44.mjs';
+export { b as EdgeRouteFilterCache, c as EdgeRouteFilterOptions, d as EdgeRouteRecord, e as ManifestCache } from './models-C8OdCO44.mjs';
+import { HandleOptions } from './middleware.mjs';
+export { C as CreateCachedManifestProviderOptions, a as CreateLearnedEdgeRouteFilterOptions, c as createCachedManifestProvider, b as createLearnedEdgeRouteFilter } from './createCachedManifestProvider-2-2u3PYd.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'];
+    /**
+     * Decides which published pages are processed at the edge, such as `vercelEdgeRouteFilter` from
+     * `@uniformdev/next-app-router/vercel`, `createLearnedEdgeRouteFilter` or
+     * `createStaticEdgeRouteFilter`. Pages it skips are rewritten without processing, stay cacheable
+     * by the CDN, and have their variants chosen in the browser.
+     *
+     * @defaultValue every published page is processed
+     */
+    filter?: EdgeRouteFilter;
+};
+/**
+ * Returns middleware that rewrites each request to its Uniform code like `uniformMiddleware`, and
+ * processes the NESI tags in the page at the edge. Published pages that the `filter` processes get
+ * `edgeMode` in their page state, so `UniformComposition` renders their personalizations and
+ * tests between NESI tags. HTML document requests for those pages fetch the page and keep only the
+ * visitor's variants. Client navigations, prefetches, draft requests and pages the filter skips
+ * 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 the manifest provider
+ * and the filter for background work, and defaults to letting the promise run unobserved.
+ */
+declare const handleUniformEdgeRoute: ({ request, manifest, onError, filter, waitUntil, ...options }: UniformEdgeMiddlewareOptions & {
+    request: NextRequest;
+    waitUntil?: ManifestProviderOptions["waitUntil"];
+}) => Promise<Response>;
+
+type CreateStaticEdgeRouteFilterOptions = {
+    /**
+     * Project map paths whose pages contain personalizations or tests, for example `/` or
+     * `/products/:slug`. A `:name` segment matches any single segment. Query strings are ignored.
+     */
+    paths: string[];
+};
+/**
+ * Creates an edge route filter that processes only the pages whose route path matches one of
+ * `paths`. Pages outside the list keep their personalizations and tests, which the browser chooses.
+ */
+declare const createStaticEdgeRouteFilter: ({ paths, }: CreateStaticEdgeRouteFilterOptions) => EdgeRouteFilter;
+
+export { type CreateStaticEdgeRouteFilterOptions, EdgeRouteFilter, ManifestProvider, ManifestProviderOptions, UNIFORM_EDGE_ORIGIN_HEADER, type UniformEdgeMiddlewareOptions, createStaticEdgeRouteFilter, handleUniformEdgeRoute, uniformEdgeMiddleware };

package/dist/edge.d.ts

@@ -0,0 +1,80 @@
+import { ManifestV2 } from '@uniformdev/context';
+import { TransformEdgeStreamOptions } from '@uniformdev/context-edge';
+import { NextRequest, NextFetchEvent } from 'next/server';
+import { M as ManifestProvider, E as EdgeRouteFilter, a as ManifestProviderOptions } from './models-C8OdCO44.js';
+export { b as EdgeRouteFilterCache, c as EdgeRouteFilterOptions, d as EdgeRouteRecord, e as ManifestCache } from './models-C8OdCO44.js';
+import { HandleOptions } from './middleware.js';
+export { C as CreateCachedManifestProviderOptions, a as CreateLearnedEdgeRouteFilterOptions, c as createCachedManifestProvider, b as createLearnedEdgeRouteFilter } from './createCachedManifestProvider-BoorKD15.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'];
+    /**
+     * Decides which published pages are processed at the edge, such as `vercelEdgeRouteFilter` from
+     * `@uniformdev/next-app-router/vercel`, `createLearnedEdgeRouteFilter` or
+     * `createStaticEdgeRouteFilter`. Pages it skips are rewritten without processing, stay cacheable
+     * by the CDN, and have their variants chosen in the browser.
+     *
+     * @defaultValue every published page is processed
+     */
+    filter?: EdgeRouteFilter;
+};
+/**
+ * Returns middleware that rewrites each request to its Uniform code like `uniformMiddleware`, and
+ * processes the NESI tags in the page at the edge. Published pages that the `filter` processes get
+ * `edgeMode` in their page state, so `UniformComposition` renders their personalizations and
+ * tests between NESI tags. HTML document requests for those pages fetch the page and keep only the
+ * visitor's variants. Client navigations, prefetches, draft requests and pages the filter skips
+ * 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 the manifest provider
+ * and the filter for background work, and defaults to letting the promise run unobserved.
+ */
+declare const handleUniformEdgeRoute: ({ request, manifest, onError, filter, waitUntil, ...options }: UniformEdgeMiddlewareOptions & {
+    request: NextRequest;
+    waitUntil?: ManifestProviderOptions["waitUntil"];
+}) => Promise<Response>;
+
+type CreateStaticEdgeRouteFilterOptions = {
+    /**
+     * Project map paths whose pages contain personalizations or tests, for example `/` or
+     * `/products/:slug`. A `:name` segment matches any single segment. Query strings are ignored.
+     */
+    paths: string[];
+};
+/**
+ * Creates an edge route filter that processes only the pages whose route path matches one of
+ * `paths`. Pages outside the list keep their personalizations and tests, which the browser chooses.
+ */
+declare const createStaticEdgeRouteFilter: ({ paths, }: CreateStaticEdgeRouteFilterOptions) => EdgeRouteFilter;
+
+export { type CreateStaticEdgeRouteFilterOptions, EdgeRouteFilter, ManifestProvider, ManifestProviderOptions, UNIFORM_EDGE_ORIGIN_HEADER, type UniformEdgeMiddlewareOptions, createStaticEdgeRouteFilter, handleUniformEdgeRoute, uniformEdgeMiddleware };