@uniformdev/next-app-router 20.81.1-alpha.4.sha-de16ebeee7 → 20.81.1

package/dist/client-BElN_CWD.d.mts

@@ -0,0 +1,786 @@
+import { RouteGetParameters, RouteGetResponse, RouteClient, RouteGetResponseEdgehancedComposition } from '@uniformdev/canvas';
+import { ManifestV2 } from '@uniformdev/context';
+import { PageState } from '@uniformdev/next-app-router-shared';
+
+type GetRouteFromMiddlewareOptions = {
+    source: 'middleware';
+    route: Omit<RouteGetParameters, 'projectId'>;
+    searchParams: URLSearchParams;
+    draftModeEnabled: boolean;
+};
+type GetRouteFromPageStateOptions = {
+    source: 'pageState';
+    pageState: PageState;
+};
+type GetRouteOptions = GetRouteFromMiddlewareOptions | GetRouteFromPageStateOptions;
+type GetRouteFromApiOptions = {
+    source: GetRouteOptions['source'];
+    route: Omit<RouteGetParameters, 'projectId'>;
+    routeClient: RouteClient;
+    enableRuntimeCache: boolean;
+    disableSwrCache: boolean;
+};
+type GetRouteResult = {
+    route: RouteGetResponse | null;
+};
+interface DataClient {
+    getManifest: (options: GetManifestOptions) => Promise<ManifestV2 | null>;
+    getRoute(options: GetRouteOptions): Promise<GetRouteResult>;
+}
+type RewriteRouteMiddlewareOptions = {
+    source: 'middleware';
+    routeClient: RouteClient;
+    route: Omit<RouteGetParameters, 'projectId'>;
+    searchParams: URLSearchParams;
+    draftModeEnabled: boolean;
+};
+type RewriteRoutePageStateOptions = {
+    source: 'pageState';
+    routeClient: RouteClient;
+    route: Omit<RouteGetParameters, 'projectId'>;
+};
+type RewriteRouteOptions = RewriteRouteMiddlewareOptions | RewriteRoutePageStateOptions;
+type RewriteRouteResult = {
+    route: RewriteRouteOptions['route'] | null;
+};
+type EnhanceRouteOptions = {
+    source: GetRouteOptions['source'];
+    parameters: Omit<RouteGetParameters, 'projectId'>;
+    route: RouteGetResponseEdgehancedComposition;
+    routeClient: RouteClient;
+    keys: Record<string, string> | undefined;
+};
+type GetManifestOptions = {
+    source: GetRouteOptions['source'];
+};
+declare class DefaultDataClient implements DataClient {
+    getManifest(options: GetManifestOptions): Promise<ManifestV2 | null>;
+    protected getRouteFromApi({ route, routeClient, enableRuntimeCache, disableSwrCache, }: GetRouteFromApiOptions): Promise<{
+        matchedRoute: string;
+        dynamicInputs?: {
+            [key: string]: string;
+        };
+        dataResourcesVariant?: "unpublished";
+        type: "composition";
+        compositionApiResponse: {
+            state: number;
+            uiStatus?: "Draft" | "Modified" | "Published" | "Orphan" | "Previous" | "Unknown";
+            projectId: string;
+            created: string;
+            modified: string;
+            deletedAt?: string;
+            creator?: string;
+            author?: string;
+            categoryId?: string;
+            description?: string;
+            previewImageUrl?: string;
+            pattern: boolean;
+            patternType?: "component" | "composition";
+            releaseId?: string;
+            composition: {
+                type: string;
+                parameters?: {
+                    [key: string]: {
+                        value?: unknown;
+                        type: string;
+                        connectedData?: {
+                            pointer: string;
+                            syntax: "jptr";
+                            failureAction?: "t" | "p" | "c" | "a";
+                            failureLogLevel?: "e" | "w" | "i";
+                            failureDefault?: string;
+                        };
+                        locales?: {
+                            [key: string]: unknown;
+                        };
+                        conditions?: {
+                            when: {
+                                op?: "&" | "|";
+                                clauses: ({
+                                    rule: string;
+                                    source?: string;
+                                    op: string;
+                                    value: string | string[];
+                                } | /*elided*/ any)[];
+                            };
+                            value: unknown;
+                            id: number;
+                        }[];
+                        localesConditions?: {
+                            [key: string]: {
+                                when: {
+                                    op?: "&" | "|";
+                                    clauses: ({
+                                        rule: string;
+                                        source?: string;
+                                        op: string;
+                                        value: string | string[];
+                                    } | /*elided*/ any)[];
+                                };
+                                value: unknown;
+                                id: number;
+                            }[];
+                        };
+                    };
+                };
+                variant?: string;
+                projectMapNodes?: {
+                    id: string;
+                    path: string;
+                    projectMapId: string;
+                    data?: {
+                        isSearchHit?: boolean;
+                        queryStrings?: {
+                            name: string;
+                            value?: string;
+                            helpText?: string;
+                            editorVisibility?: "opt-in";
+                            optionsSource?: {
+                                source: "static";
+                                options: {
+                                    name: string;
+                                    value: string;
+                                }[];
+                            };
+                        }[];
+                        previewValue?: string;
+                    };
+                    locales?: {
+                        [key: string]: {
+                            path: string;
+                            inherited: boolean;
+                        };
+                    };
+                }[];
+                slots?: {
+                    [key: string]: {
+                        type: string;
+                        parameters?: {
+                            [key: string]: {
+                                value?: unknown;
+                                type: string;
+                                connectedData?: {
+                                    pointer: string;
+                                    syntax: "jptr";
+                                    failureAction?: "t" | "p" | "c" | "a";
+                                    failureLogLevel?: "e" | "w" | "i";
+                                    failureDefault?: string;
+                                };
+                                locales?: {
+                                    [key: string]: unknown;
+                                };
+                                conditions?: {
+                                    when: {
+                                        op?: "&" | "|";
+                                        clauses: ({
+                                            rule: string;
+                                            source?: string;
+                                            op: string;
+                                            value: string | string[];
+                                        } | /*elided*/ any)[];
+                                    };
+                                    value: unknown;
+                                    id: number;
+                                }[];
+                                localesConditions?: {
+                                    [key: string]: {
+                                        when: {
+                                            op?: "&" | "|";
+                                            clauses: ({
+                                                rule: string;
+                                                source?: string;
+                                                op: string;
+                                                value: string | string[];
+                                            } | /*elided*/ any)[];
+                                        };
+                                        value: unknown;
+                                        id: number;
+                                    }[];
+                                };
+                            };
+                        };
+                        variant?: string;
+                        slots?: {
+                            [key: string]: /*elided*/ any[];
+                        };
+                        _id?: string;
+                        _pattern?: string;
+                        _dataResources?: {
+                            [key: string]: {
+                                type: string;
+                                isPatternParameter?: boolean;
+                                ignorePatternParameterDefault?: boolean;
+                                optionalPatternParameter?: boolean;
+                                variables?: {
+                                    [key: string]: string;
+                                };
+                            };
+                        };
+                        _patternDataResources?: {
+                            [key: string]: {
+                                type: string;
+                                isPatternParameter?: boolean;
+                                ignorePatternParameterDefault?: boolean;
+                                optionalPatternParameter?: boolean;
+                                variables?: {
+                                    [key: string]: string;
+                                };
+                            };
+                        };
+                        _patternOptedInQueryStrings?: string[];
+                        _patternError?: "NOTFOUND" | "CYCLIC";
+                        _overrides?: {
+                            [key: string]: {
+                                parameters?: {
+                                    [key: string]: {
+                                        value?: unknown;
+                                        type: string;
+                                        connectedData?: {
+                                            pointer: string;
+                                            syntax: "jptr";
+                                            failureAction?: "t" | "p" | "c" | "a";
+                                            failureLogLevel?: "e" | "w" | "i";
+                                            failureDefault?: string;
+                                        };
+                                        locales?: {
+                                            [key: string]: unknown;
+                                        };
+                                        conditions?: {
+                                            when: {
+                                                op?: "&" | "|";
+                                                clauses: ({
+                                                    rule: string;
+                                                    source?: string;
+                                                    op: string;
+                                                    value: string | string[];
+                                                } | /*elided*/ any)[];
+                                            };
+                                            value: unknown;
+                                            id: number;
+                                        }[];
+                                        localesConditions?: {
+                                            [key: string]: {
+                                                when: {
+                                                    op?: "&" | "|";
+                                                    clauses: ({
+                                                        rule: string;
+                                                        source?: string;
+                                                        op: string;
+                                                        value: string | string[];
+                                                    } | /*elided*/ any)[];
+                                                };
+                                                value: unknown;
+                                                id: number;
+                                            }[];
+                                        };
+                                    };
+                                };
+                                slots?: {
+                                    [key: string]: /*elided*/ any[];
+                                };
+                                variant?: string;
+                                dataResources?: {
+                                    [key: string]: {
+                                        type: string;
+                                        isPatternParameter?: boolean;
+                                        ignorePatternParameterDefault?: boolean;
+                                        optionalPatternParameter?: boolean;
+                                        variables?: {
+                                            [key: string]: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        _patternOverrides?: {
+                            [key: string]: {
+                                parameters?: {
+                                    [key: string]: {
+                                        value?: unknown;
+                                        type: string;
+                                        connectedData?: {
+                                            pointer: string;
+                                            syntax: "jptr";
+                                            failureAction?: "t" | "p" | "c" | "a";
+                                            failureLogLevel?: "e" | "w" | "i";
+                                            failureDefault?: string;
+                                        };
+                                        locales?: {
+                                            [key: string]: unknown;
+                                        };
+                                        conditions?: {
+                                            when: {
+                                                op?: "&" | "|";
+                                                clauses: ({
+                                                    rule: string;
+                                                    source?: string;
+                                                    op: string;
+                                                    value: string | string[];
+                                                } | /*elided*/ any)[];
+                                            };
+                                            value: unknown;
+                                            id: number;
+                                        }[];
+                                        localesConditions?: {
+                                            [key: string]: {
+                                                when: {
+                                                    op?: "&" | "|";
+                                                    clauses: ({
+                                                        rule: string;
+                                                        source?: string;
+                                                        op: string;
+                                                        value: string | string[];
+                                                    } | /*elided*/ any)[];
+                                                };
+                                                value: unknown;
+                                                id: number;
+                                            }[];
+                                        };
+                                    };
+                                };
+                                slots?: {
+                                    [key: string]: /*elided*/ any[];
+                                };
+                                variant?: string;
+                                dataResources?: {
+                                    [key: string]: {
+                                        type: string;
+                                        isPatternParameter?: boolean;
+                                        ignorePatternParameterDefault?: boolean;
+                                        optionalPatternParameter?: boolean;
+                                        variables?: {
+                                            [key: string]: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        _overridability?: {
+                            parameters?: {
+                                [key: string]: "yes" | "no";
+                            };
+                            variants?: boolean;
+                            hideLockedParameters?: boolean;
+                        };
+                        _locales?: string[];
+                    }[];
+                };
+                _id: string;
+                _slug?: string | null;
+                _name: string;
+                _author?: string;
+                _authorSubject?: string;
+                _creator?: string;
+                _creatorSubject?: string;
+                _pattern?: string;
+                _patternDataResources?: {
+                    [key: string]: {
+                        type: string;
+                        isPatternParameter?: boolean;
+                        ignorePatternParameterDefault?: boolean;
+                        optionalPatternParameter?: boolean;
+                        variables?: {
+                            [key: string]: string;
+                        };
+                    };
+                };
+                _patternOptedInQueryStrings?: string[];
+                _dataResources?: {
+                    [key: string]: {
+                        type: string;
+                        isPatternParameter?: boolean;
+                        ignorePatternParameterDefault?: boolean;
+                        optionalPatternParameter?: boolean;
+                        variables?: {
+                            [key: string]: string;
+                        };
+                    };
+                };
+                _patternError?: "NOTFOUND" | "CYCLIC";
+                _overrides?: {
+                    [key: string]: {
+                        parameters?: {
+                            [key: string]: {
+                                value?: unknown;
+                                type: string;
+                                connectedData?: {
+                                    pointer: string;
+                                    syntax: "jptr";
+                                    failureAction?: "t" | "p" | "c" | "a";
+                                    failureLogLevel?: "e" | "w" | "i";
+                                    failureDefault?: string;
+                                };
+                                locales?: {
+                                    [key: string]: unknown;
+                                };
+                                conditions?: {
+                                    when: {
+                                        op?: "&" | "|";
+                                        clauses: ({
+                                            rule: string;
+                                            source?: string;
+                                            op: string;
+                                            value: string | string[];
+                                        } | /*elided*/ any)[];
+                                    };
+                                    value: unknown;
+                                    id: number;
+                                }[];
+                                localesConditions?: {
+                                    [key: string]: {
+                                        when: {
+                                            op?: "&" | "|";
+                                            clauses: ({
+                                                rule: string;
+                                                source?: string;
+                                                op: string;
+                                                value: string | string[];
+                                            } | /*elided*/ any)[];
+                                        };
+                                        value: unknown;
+                                        id: number;
+                                    }[];
+                                };
+                            };
+                        };
+                        slots?: {
+                            [key: string]: {
+                                type: string;
+                                parameters?: {
+                                    [key: string]: {
+                                        value?: unknown;
+                                        type: string;
+                                        connectedData?: {
+                                            pointer: string;
+                                            syntax: "jptr";
+                                            failureAction?: "t" | "p" | "c" | "a";
+                                            failureLogLevel?: "e" | "w" | "i";
+                                            failureDefault?: string;
+                                        };
+                                        locales?: {
+                                            [key: string]: unknown;
+                                        };
+                                        conditions?: {
+                                            when: {
+                                                op?: "&" | "|";
+                                                clauses: ({
+                                                    rule: string;
+                                                    source?: string;
+                                                    op: string;
+                                                    value: string | string[];
+                                                } | /*elided*/ any)[];
+                                            };
+                                            value: unknown;
+                                            id: number;
+                                        }[];
+                                        localesConditions?: {
+                                            [key: string]: {
+                                                when: {
+                                                    op?: "&" | "|";
+                                                    clauses: ({
+                                                        rule: string;
+                                                        source?: string;
+                                                        op: string;
+                                                        value: string | string[];
+                                                    } | /*elided*/ any)[];
+                                                };
+                                                value: unknown;
+                                                id: number;
+                                            }[];
+                                        };
+                                    };
+                                };
+                                variant?: string;
+                                slots?: {
+                                    [key: string]: /*elided*/ any[];
+                                };
+                                _id?: string;
+                                _pattern?: string;
+                                _dataResources?: {
+                                    [key: string]: {
+                                        type: string;
+                                        isPatternParameter?: boolean;
+                                        ignorePatternParameterDefault?: boolean;
+                                        optionalPatternParameter?: boolean;
+                                        variables?: {
+                                            [key: string]: string;
+                                        };
+                                    };
+                                };
+                                _patternDataResources?: {
+                                    [key: string]: {
+                                        type: string;
+                                        isPatternParameter?: boolean;
+                                        ignorePatternParameterDefault?: boolean;
+                                        optionalPatternParameter?: boolean;
+                                        variables?: {
+                                            [key: string]: string;
+                                        };
+                                    };
+                                };
+                                _patternOptedInQueryStrings?: string[];
+                                _patternError?: "NOTFOUND" | "CYCLIC";
+                                _overrides?: {
+                                    [key: string]: /*elided*/ any;
+                                };
+                                _patternOverrides?: {
+                                    [key: string]: /*elided*/ any;
+                                };
+                                _overridability?: {
+                                    parameters?: {
+                                        [key: string]: "yes" | "no";
+                                    };
+                                    variants?: boolean;
+                                    hideLockedParameters?: boolean;
+                                };
+                                _locales?: string[];
+                            }[];
+                        };
+                        variant?: string;
+                        dataResources?: {
+                            [key: string]: {
+                                type: string;
+                                isPatternParameter?: boolean;
+                                ignorePatternParameterDefault?: boolean;
+                                optionalPatternParameter?: boolean;
+                                variables?: {
+                                    [key: string]: string;
+                                };
+                            };
+                        };
+                    };
+                };
+                _patternOverrides?: {
+                    [key: string]: {
+                        parameters?: {
+                            [key: string]: {
+                                value?: unknown;
+                                type: string;
+                                connectedData?: {
+                                    pointer: string;
+                                    syntax: "jptr";
+                                    failureAction?: "t" | "p" | "c" | "a";
+                                    failureLogLevel?: "e" | "w" | "i";
+                                    failureDefault?: string;
+                                };
+                                locales?: {
+                                    [key: string]: unknown;
+                                };
+                                conditions?: {
+                                    when: {
+                                        op?: "&" | "|";
+                                        clauses: ({
+                                            rule: string;
+                                            source?: string;
+                                            op: string;
+                                            value: string | string[];
+                                        } | /*elided*/ any)[];
+                                    };
+                                    value: unknown;
+                                    id: number;
+                                }[];
+                                localesConditions?: {
+                                    [key: string]: {
+                                        when: {
+                                            op?: "&" | "|";
+                                            clauses: ({
+                                                rule: string;
+                                                source?: string;
+                                                op: string;
+                                                value: string | string[];
+                                            } | /*elided*/ any)[];
+                                        };
+                                        value: unknown;
+                                        id: number;
+                                    }[];
+                                };
+                            };
+                        };
+                        slots?: {
+                            [key: string]: {
+                                type: string;
+                                parameters?: {
+                                    [key: string]: {
+                                        value?: unknown;
+                                        type: string;
+                                        connectedData?: {
+                                            pointer: string;
+                                            syntax: "jptr";
+                                            failureAction?: "t" | "p" | "c" | "a";
+                                            failureLogLevel?: "e" | "w" | "i";
+                                            failureDefault?: string;
+                                        };
+                                        locales?: {
+                                            [key: string]: unknown;
+                                        };
+                                        conditions?: {
+                                            when: {
+                                                op?: "&" | "|";
+                                                clauses: ({
+                                                    rule: string;
+                                                    source?: string;
+                                                    op: string;
+                                                    value: string | string[];
+                                                } | /*elided*/ any)[];
+                                            };
+                                            value: unknown;
+                                            id: number;
+                                        }[];
+                                        localesConditions?: {
+                                            [key: string]: {
+                                                when: {
+                                                    op?: "&" | "|";
+                                                    clauses: ({
+                                                        rule: string;
+                                                        source?: string;
+                                                        op: string;
+                                                        value: string | string[];
+                                                    } | /*elided*/ any)[];
+                                                };
+                                                value: unknown;
+                                                id: number;
+                                            }[];
+                                        };
+                                    };
+                                };
+                                variant?: string;
+                                slots?: {
+                                    [key: string]: /*elided*/ any[];
+                                };
+                                _id?: string;
+                                _pattern?: string;
+                                _dataResources?: {
+                                    [key: string]: {
+                                        type: string;
+                                        isPatternParameter?: boolean;
+                                        ignorePatternParameterDefault?: boolean;
+                                        optionalPatternParameter?: boolean;
+                                        variables?: {
+                                            [key: string]: string;
+                                        };
+                                    };
+                                };
+                                _patternDataResources?: {
+                                    [key: string]: {
+                                        type: string;
+                                        isPatternParameter?: boolean;
+                                        ignorePatternParameterDefault?: boolean;
+                                        optionalPatternParameter?: boolean;
+                                        variables?: {
+                                            [key: string]: string;
+                                        };
+                                    };
+                                };
+                                _patternOptedInQueryStrings?: string[];
+                                _patternError?: "NOTFOUND" | "CYCLIC";
+                                _overrides?: {
+                                    [key: string]: /*elided*/ any;
+                                };
+                                _patternOverrides?: {
+                                    [key: string]: /*elided*/ any;
+                                };
+                                _overridability?: {
+                                    parameters?: {
+                                        [key: string]: "yes" | "no";
+                                    };
+                                    variants?: boolean;
+                                    hideLockedParameters?: boolean;
+                                };
+                                _locales?: string[];
+                            }[];
+                        };
+                        variant?: string;
+                        dataResources?: {
+                            [key: string]: {
+                                type: string;
+                                isPatternParameter?: boolean;
+                                ignorePatternParameterDefault?: boolean;
+                                optionalPatternParameter?: boolean;
+                                variables?: {
+                                    [key: string]: string;
+                                };
+                            };
+                        };
+                    };
+                };
+                _overridability?: {
+                    parameters?: {
+                        [key: string]: "yes" | "no";
+                    };
+                    variants?: boolean;
+                    hideLockedParameters?: boolean;
+                };
+                _locales?: string[];
+                _optedInQueryStrings?: string[];
+            };
+            workflowId?: string;
+            workflowStageId?: string;
+            workflowDefinition?: {
+                id: string;
+                name: string;
+                initialStage: string;
+                stages: {
+                    [key: string]: {
+                        name: string;
+                        permissions: {
+                            [key: string]: {
+                                write?: boolean;
+                                publish?: boolean;
+                            };
+                        };
+                        autoPublish?: boolean;
+                        requireValidity?: boolean;
+                        transitions: {
+                            to: string;
+                            name: string;
+                            permissions: {
+                                [key: string]: {
+                                    execute?: boolean;
+                                };
+                            };
+                        }[];
+                        icon?: string;
+                        order?: number;
+                    };
+                };
+                modified?: string;
+                created?: string;
+                createdBy?: string;
+                modifiedBy?: string;
+            };
+            editionId?: string;
+            editionName?: string;
+            editionPriority?: number;
+        };
+    } | {
+        matchedRoute: string;
+        dynamicInputs?: {
+            [key: string]: string;
+        };
+        type: "redirect";
+        redirect: {
+            id?: string;
+            sourceUrl: string;
+            targetUrl: string;
+            targetStatusCode: number;
+            sourceProjectMapNodeId?: string;
+            targetProjectMapNodeId?: string;
+            projectMapId?: string;
+            sourceRetainQuerystring?: boolean;
+            sourceMustMatchDomain?: boolean;
+            targetPreserveIncomingProtocol?: boolean;
+            targetPreserveIncomingDomain?: boolean;
+            targetMergeQuerystring?: boolean;
+            labelAsSystem?: boolean;
+        };
+    } | {
+        type: "notFound";
+    }>;
+    getRoute(options: GetRouteOptions): Promise<GetRouteResult>;
+    protected enhanceRoute(_options: EnhanceRouteOptions): Promise<void>;
+    protected getRouteMiddleware(options: GetRouteFromMiddlewareOptions): Promise<GetRouteResult>;
+    protected getRoutePageState(options: GetRouteFromPageStateOptions): Promise<GetRouteResult>;
+}
+declare const expireMiddlewareCacheTag: (tag: string | string[]) => Promise<void>;
+
+export { type DataClient as D, type EnhanceRouteOptions as E, type GetRouteFromMiddlewareOptions as G, type RewriteRouteOptions as R, DefaultDataClient as a, type GetRouteFromPageStateOptions as b, type GetRouteOptions as c, type RewriteRouteResult as d, expireMiddlewareCacheTag as e };