@zengenti/contensis-react-base 4.0.0-beta.2 → 4.0.0-beta.3

package/models/models/ContentTypeMapping.d.ts

@@ -0,0 +1,89 @@
+import { FieldLinkDepths } from 'contensis-core-api';
+import { EntryMapper } from './EntryMapper';
+import { ReduxInjector } from './ReduxInjector';
+import { RouteComponent } from './RouteComponent';
+import { RouteComponentProps } from './RouteComponentProps';
+import { RequireLogin } from './RequireLogin';
+export type ContentTypeMapping = {
+    /** The unique identifier for the content type to map. */
+    contentTypeID: string;
+    /**
+     * The React component that should be rendered for this content type.
+     */
+    component: RouteComponent<RouteComponentProps>;
+    /**
+     * Optional entry mapper to transform entry data before passing it to the component.
+     */
+    entryMapper?: EntryMapper;
+    /**
+     * An array of field IDs used to restrict the fields returned for an entry.
+     */
+    fields?: string[];
+    /**
+     * Injects Redux dependencies or actions into the route if needed.
+     */
+    injectRedux?: ReduxInjector;
+    /**
+     * The depth at which to resolve the full entry data for a linked entry or asset.
+     * Maximum depth is 10, with a recommended maximum of 4.
+     *
+     * A default depth of 2 is applied via `routeLoadOptions` in `onRouteLoad`.
+     */
+    linkDepth?: number;
+    /**
+     * Custom link depths for specific field paths to resolve full entry data for a linked entry or asset.
+     * Maximum depth is 10, with a recommended maximum of 4.
+     *
+     * This option is available only in Contensis version 16+.
+     */
+    fieldLinkDepths?: FieldLinkDepths;
+    /**
+     * Options for configuring how Site View Node data is handled, including children and siblings.
+     */
+    nodeOptions?: {
+        children?: {
+            /** The depth of descendants to include for the node. */
+            depth: number;
+            /**
+             * An array of field IDs used to restrict the fields returned for each entry.
+             */
+            fields?: string[];
+            /**
+             * The depth at which to resolve the full entry data for a linked entry or asset.
+             * Maximum depth is 10, with a recommended maximum of 4.
+             *
+             * A default depth of 2 is applied via `routeLoadOptions` in `onRouteLoad`.
+             */
+            linkDepth?: number;
+            /**
+             * Custom link depths for specific field paths to resolve full entry data for a linked entry or asset.
+             * Maximum depth is 10, with a recommended maximum of 4.
+             *
+             * This option is available only in Contensis version 16+.
+             */
+            fieldLinkDepths?: FieldLinkDepths;
+        } | boolean;
+        siblings?: {
+            /** The depth of descendants to include for the node. */
+            fields?: string[];
+            /**
+             * The depth at which to resolve the full entry data for a linked entry or asset.
+             * Maximum depth is 10, with a recommended maximum of 4.
+             *
+             * A default depth of 2 is applied via `routeLoadOptions` in `onRouteLoad`.
+             */
+            linkDepth?: number;
+            /**
+             * Custom link depths for specific field paths to resolve full entry data for a linked entry or asset.
+             * Maximum depth is 10, with a recommended maximum of 4.
+             *
+             * This option is available only in Contensis version 16+.
+             */
+            fieldLinkDepths?: FieldLinkDepths;
+        } | boolean;
+    };
+    /**
+     * Specifies whether login is required to access the content for this type.
+     */
+    requireLogin?: RequireLogin;
+};

package/models/models/EntryMapper.d.ts

@@ -0,0 +1,3 @@
+import { AppState } from './AppState';
+import { RouteNode } from './RouteNode';
+export type EntryMapper = (<MappedProps>(node: RouteNode, state?: AppState) => MappedProps | unknown) | (<MappedProps>(node: RouteNode, state?: AppState) => Promise<MappedProps | unknown>);

package/models/models/GetRouteActionArgs.d.ts

@@ -0,0 +1,15 @@
+import { useLocation } from 'react-router-dom';
+import { AppRoutes } from './AppRouteProps';
+import { MatchedRoute } from './MatchedRoute';
+import { SSRContext } from './SSRContext';
+import { StaticRoute } from './StaticRoute';
+import { WithEvents } from './WithEvents';
+export type GetRouteActionArgs = {
+    location: ReturnType<typeof useLocation>;
+    path: string;
+    routes: AppRoutes;
+    ssr: SSRContext;
+    staticRoute?: MatchedRoute<any, StaticRoute>;
+    statePath: string;
+    withEvents: WithEvents;
+};

package/models/models/MatchedRoute.d.ts

@@ -0,0 +1,4 @@
+import type { RouteObject, RouteMatch } from 'react-router';
+export type MatchedRoute<ParamKey extends string = string, TRouteObject extends RouteObject = RouteObject> = Omit<RouteMatch<ParamKey>, 'route'> & {
+    route: TRouteObject;
+};

package/models/models/ReduxInjector.d.ts

@@ -0,0 +1,5 @@
+export type ReduxInjector = () => Promise<{
+    key: string;
+    reducer: any;
+    saga: any;
+}>;

package/models/models/RequireLogin.d.ts

@@ -0,0 +1,6 @@
+type UserGroupRequisite = {
+    id?: string;
+    name?: string;
+};
+export type RequireLogin = boolean | UserGroupRequisite[];
+export {};

package/models/models/RouteComponent.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { LoadableComponent } from '@loadable/component';
+import { RouteComponentProps } from './RouteComponentProps';
+export type RouteComponent<Props> = LoadableComponent<RouteComponentProps> | React.ComponentType<Props>;

package/models/models/RouteComponentProps.d.ts

@@ -0,0 +1,9 @@
+import { Entry } from 'contensis-delivery-api';
+export type RouteComponentProps<P = any> = {
+    [key: string]: any;
+    projectId?: string;
+    contentTypeId?: string;
+    entry?: Entry | null;
+    mappedEntry?: P;
+    isLoggedIn?: boolean;
+};

package/models/models/RouteLoaderProps.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type RouteLoaderProps = {
+    loadingComponent?: React.ComponentType;
+    notFoundComponent?: React.ComponentType<{
+        statusCode: number;
+        statusText: string;
+    }>;
+    trailingSlashRedirectCode?: 301 | 302;
+};

package/models/models/RouteNode.d.ts

@@ -0,0 +1,5 @@
+import { Node } from 'contensis-delivery-api';
+export type RouteNode = Node & {
+    ancestors: Node[];
+    children: Node[];
+};

package/models/models/SSRContext.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response } from 'express';
+import { Dispatch } from "../../node_modules/redux";
+import { CookieHelper } from "../user/util/CookieHelper.class";
+import { cachedSearchWithCookies } from "../util";
+export type SSRContext = {
+    api: ReturnType<typeof cachedSearchWithCookies>;
+    cookies: CookieHelper;
+    dispatch: Dispatch<any>;
+    request?: Request;
+    response?: Response;
+};

package/models/models/StaticRoute.d.ts

@@ -0,0 +1,60 @@
+import { FieldLinkDepths } from 'contensis-core-api';
+import { RouteComponent } from './RouteComponent';
+import { RouteComponentProps } from './RouteComponentProps';
+import { EntryMapper } from './EntryMapper';
+import { ReduxInjector } from './ReduxInjector';
+import { RequireLogin } from './RequireLogin';
+import type { RouteObject } from 'react-router';
+export type StaticRoute = Omit<RouteObject, 'children'> & {
+    index?: false | undefined;
+    /**
+     * The React component that should be rendered for this route.
+     */
+    component?: RouteComponent<RouteComponentProps>;
+    /**
+     * Options for configuring how Site View Node data is handled.
+     */
+    children?: StaticRoute[];
+    fetchNode?: boolean | {
+        /**
+         * Params[] allows you pass parameters into the site view query on your static node fetch
+         * If your route is `/authors/:author` and your params[] array has author
+         * `{ params: [ 'author' ] }`, this will grab the route params and replace it with it's value
+         * e.g `{` author: 'jane-doe' }`, your path would become `/authors/jane-doe`
+         */
+        params?: string[];
+        /**
+         * The depth at which to resolve the full entry data for a linked entry or asset.
+         * Maximum depth is 10, with a recommended maximum of 4.
+         *
+         * A default depth of 2 is applied via `routeLoadOptions` in `onRouteLoad`.
+         */
+        linkDepth?: number;
+        /**
+         * Custom link depths for specific field paths to resolve full entry data for a linked entry or asset.
+         * Maximum depth is 10, with a recommended maximum of 4.
+         *
+         * This option is available only in Contensis version 16+.
+         */
+        fieldLinkDepths?: FieldLinkDepths;
+        /** The depth of descendants to include for the node. */
+        fields?: string[];
+        /**
+         * Optional entry mapper to transform entry data before passing it to the component.
+         */
+        entryMapper?: EntryMapper;
+    };
+    /** The depth of descendants to include for the node. */
+    fetchNodeLevel?: number;
+    /**
+     * Injects Redux dependencies or actions into the route if needed.
+     */
+    injectRedux?: ReduxInjector;
+    /**
+     * Specifies whether login is required to access the content for this type.
+     */
+    requireLogin?: RequireLogin;
+    ssr?: boolean;
+    ssrOnly?: boolean;
+    fullPath?: string;
+};

package/models/models/WithEvents.d.ts

@@ -0,0 +1,58 @@
+import { FieldLinkDepths } from 'contensis-core-api';
+import { Entry } from 'contensis-delivery-api';
+import { GetRouteActionArgs } from './GetRouteActionArgs';
+import { RequireLogin } from './RequireLogin';
+export type OnRouteLoadArgs = Omit<GetRouteActionArgs, 'withEvents'>;
+export type OnRouteLoadedArgs = OnRouteLoadArgs & {
+    entry?: Entry | any;
+};
+/**
+ * Configuration options to customize the app state during route changes.
+ * These options are evaluated on each route action, establishing the "default" behavior.
+ */
+export type RouteLoadOptions = {
+    /**
+     * Determines whether to query related Site View Nodes by default during routing.
+     * Allows specifying the depth of query for ancestors, children, siblings, and the entire tree structure.
+     */
+    customNavigation?: boolean | {
+        ancestors: boolean | number;
+        children: boolean | number;
+        siblings: boolean | number;
+        tree: boolean | number;
+    };
+    customRouting?: boolean;
+    /**
+     * Sets the default language for the Site View during route changes.
+     *
+     * @default 'en-GB'
+     */
+    defaultLang?: string;
+    /**
+     * Defines the default depth for resolving full entry data for a linked entry or asset during route changes.
+     * Maximum depth is 10, with a recommended maximum of 4.
+     *
+     * @default 2
+     */
+    entryLinkDepth?: number;
+    /**
+     * Specifies custom depths for resolving full entry data for specific field paths in linked entries or assets during route changes.
+     * Maximum depth is 10, with a recommended maximum of 4.
+  
+     *
+     * Available only in Contensis version 16+.
+     */
+    entryFieldLinkDepths?: FieldLinkDepths;
+    /**
+     * Disables the automatic scroll-to-top behavior when navigating to a new route.
+     */
+    preventScrollTop?: boolean;
+    refetchNode?: true;
+};
+export type RouteLoadedOptions = {
+    requireLogin?: RequireLogin;
+};
+export type WithEvents = {
+    onRouteLoad: (args: OnRouteLoadArgs) => Generator<void | RouteLoadOptions>;
+    onRouteLoaded: (args: OnRouteLoadedArgs) => Generator<void | RouteLoadedOptions>;
+};

package/models/models/config/AppConfig.d.ts

@@ -0,0 +1,12 @@
+import { AppRoutes } from '../AppRouteProps';
+import { WithEvents } from '../WithEvents';
+import { StateType } from './StateType';
+export type AppConfig = {
+    stateType?: StateType;
+    routes: AppRoutes;
+    withReducers: {
+        [key: string]: any;
+    };
+    withSagas: any[];
+    withEvents: WithEvents;
+};

package/models/{config.d.ts → models/config/ServerConfig.d.ts}

@@ -1,18 +1,9 @@
-import { AppRoutes, WithEvents } from './routing/routes';
-import handleResponse from './server/features/response-handler';
-export type StateType = 'immutable' | 'js';
-export type AppConfig = {
-    stateType?: StateType;
-    routes: AppRoutes;
-    withReducers: {
-        [key: string]: any;
-    };
-    withSagas: any[];
-    withEvents: WithEvents;
-};
+import { AppConfig } from './AppConfig';
+import handleResponse from "../../server/features/response-handler";
 export type ServerConfig = AppConfig & {
     appRootPath?: string;
     disableSsrRedux?: boolean;
+    enableSsrCookies?: boolean;
     handleResponses?: typeof handleResponse;
     handleExceptions?: boolean | string[];
     reverseProxyPaths?: string[];

package/models/models/config/StateType.d.ts

@@ -0,0 +1 @@
+export type StateType = 'immutable' | 'js';

package/models/models/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AppConfig';
+export * from './ServerConfig';
+export * from './StateType';

package/models/models/index.d.ts

@@ -0,0 +1,16 @@
+export * from './config';
+export * from './AppRouteProps';
+export * from './AppState';
+export * from './ContentTypeMapping';
+export * from './EntryMapper';
+export * from './GetRouteActionArgs';
+export * from './MatchedRoute';
+export * from './ReduxInjector';
+export * from './RequireLogin';
+export * from './RouteComponent';
+export * from './RouteComponentProps';
+export * from './RouteLoaderProps';
+export * from './RouteNode';
+export * from './SSRContext';
+export * from './StaticRoute';
+export * from './WithEvents';

package/models/redux/actions/index.d.ts

@@ -4,6 +4,6 @@ declare namespace _default {
     export { version };
 }
 export default _default;
-import * as navigation from "./navigation";
+import * as navigation from './navigation';
 import * as routing from "../../routing/redux/actions";
-import * as version from "./version";
+import * as version from './version';

package/models/redux/sagas/navigation.d.ts

@@ -1,4 +1,2 @@
-export function ensureNodeTreeSaga(action: any): Generator<Promise<import("contensis-delivery-api/lib/models").Node> | import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<{
-    type: string;
-}>, void, unknown>;
+export function ensureNodeTreeSaga(action: any): Generator<any, void, unknown>;
 export const navigationSagas: import("redux-saga/effects").ForkEffect<never>[];

package/models/redux/selectors/index.d.ts

@@ -4,6 +4,6 @@ declare namespace _default {
     export { version };
 }
 export default _default;
-import * as navigation from "./navigation";
+import * as navigation from './navigation';
 import * as routing from "../../routing/redux/selectors";
-import * as version from "./version";
+import * as version from './version';

package/models/redux/store/injectors.d.ts

@@ -2,18 +2,30 @@ export function convertSagaArray(sagas: any): any;
 export function injectReducer({ key, reducer }: {
     key: any;
     reducer: any;
-}, store?: any): void;
+}, store?: import("../../../node_modules/redux").Store<import("../..").AppState, import("../../../node_modules/redux").Action<any>> & {
+    runSaga: <S extends import("redux-saga").Saga>(saga: S, ...args: Parameters<S>) => import("redux-saga").Task<any>;
+    close: () => void;
+}): void;
 export function injectSaga({ key, saga }: {
     key: any;
     saga: any;
-}, store?: any): void;
+}, store?: import("../../../node_modules/redux").Store<import("../..").AppState, import("../../../node_modules/redux").Action<any>> & {
+    runSaga: <S extends import("redux-saga").Saga>(saga: S, ...args: Parameters<S>) => import("redux-saga").Task<any>;
+    close: () => void;
+}): void;
 export function injectRedux({ key, reducer, saga }: {
     key: any;
     reducer: any;
     saga: any;
-}, store?: any): void;
+}, store?: import("../../../node_modules/redux").Store<import("../..").AppState, import("../../../node_modules/redux").Action<any>> & {
+    runSaga: <S extends import("redux-saga").Saga>(saga: S, ...args: Parameters<S>) => import("redux-saga").Task<any>;
+    close: () => void;
+}): void;
 export function useInjectRedux({ key, reducer, saga }: {
     key: any;
     reducer: any;
     saga: any;
-}, store?: any): void;
+}, store?: import("../../../node_modules/redux").Store<import("../..").AppState, import("../../../node_modules/redux").Action<any>> & {
+    runSaga: <S extends import("redux-saga").Saga>(saga: S, ...args: Parameters<S>) => import("redux-saga").Task<any>;
+    close: () => void;
+}): void;

package/models/redux/store/store.d.ts

@@ -1,6 +1,12 @@
-import { AppState } from '../appstate';
+import { Action, Store } from "../../../node_modules/redux";
+import createSagaMiddleware from 'redux-saga';
+import { AppState, StateType } from "../../models";
 import { History, MemoryHistory } from 'history';
-import { StateType } from "../../config";
-export declare let reduxStore: any;
-declare const _default: (featureReducers: any, initialState: AppState, history: History | MemoryHistory, stateType: StateType) => Promise<any>;
+type ReduxAppStore = Store<AppState, Action<any>>;
+type ReduxSagaAppStore = ReduxAppStore & {
+    runSaga: ReturnType<typeof createSagaMiddleware>['run'];
+    close: () => void;
+};
+export declare let reduxStore: ReduxSagaAppStore;
+declare const _default: (featureReducers: any, initialState: AppState, history: History | MemoryHistory, stateType: StateType) => Promise<ReduxSagaAppStore>;
 export default _default;

package/models/redux/types/index.d.ts

@@ -4,6 +4,6 @@ declare namespace _default {
     export { version };
 }
 export default _default;
-import * as navigation from "./navigation";
+import * as navigation from './navigation';
 import * as routing from "../../routing/redux/types";
-import * as version from "./version";
+import * as version from './version';

package/models/redux/types/navigation.d.ts

@@ -1,3 +1,3 @@
-export const GET_NODE_TREE: string;
-export const SET_NODE_TREE: string;
-export const GET_NODE_TREE_ERROR: string;
+export const GET_NODE_TREE: "@NAVIGATION/_GET_NODE_TREE";
+export const SET_NODE_TREE: "@NAVIGATION/_SET_NODE_TREE";
+export const GET_NODE_TREE_ERROR: "@NAVIGATION/_GET_NODE_TREE_ERROR";

package/models/redux/types/version.d.ts

@@ -1,2 +1,2 @@
-export const SET_VERSION: string;
-export const SET_VERSION_STATUS: string;
+export const SET_VERSION: "@VERSION/SET_VERSION";
+export const SET_VERSION_STATUS: "@VERSION/SET_VERSION_STATUS";

package/models/routing/components/Redirect.d.ts

@@ -1,5 +1,5 @@
 import React, { PropsWithChildren } from 'react';
-export declare const Redirect: ({ code, to, }: React.PropsWithChildren<{
+export declare const Redirect: ({ code, to, }: PropsWithChildren<{
     code: 301 | 302;
     to: string;
 }>) => React.JSX.Element;

package/models/routing/components/RouteLoader.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
-import { AppRootProps, RouteLoaderProps } from '../routes';
+import { AppRootProps, RouteLoaderProps } from "../../models";
 declare const _default: (props: AppRootProps & RouteLoaderProps) => JSX.Element;
 export default _default;

package/models/routing/components/StaticRouteLoader.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { StaticRoute } from '../routes';
+import type { StaticRoute } from "../../models";
 export interface StaticRouteLoaderProps {
     staticRoutes: StaticRoute[];
 }

package/models/routing/components/Status.d.ts

@@ -1,4 +1,4 @@
 import React, { PropsWithChildren } from 'react';
-export declare const Status: ({ code, children, }: React.PropsWithChildren<{
+export declare const Status: ({ code, children, }: PropsWithChildren<{
     code: number;
 }>) => React.JSX.Element;

package/models/routing/redux/actions.d.ts

@@ -1,9 +1,8 @@
 import { useLocation } from 'react-router-dom';
 import { Entry } from 'contensis-delivery-api/lib/models';
-import { AppRoutes, MatchedRoute, StaticRoute, WithEvents } from '../routes';
-import { CookieHelper } from "../../user/util/CookieHelper.class";
-export declare const setNavigationPath: (path: string, location: ReturnType<typeof useLocation>, staticRoute: MatchedRoute<string, StaticRoute> | undefined, withEvents: WithEvents, statePath: string, routes: AppRoutes, cookies: CookieHelper) => any;
+import { AppRoutes, MatchedRoute, StaticRoute, SSRContext, WithEvents } from "../../models";
+export declare const setNavigationPath: (path: string, location: ReturnType<typeof useLocation>, staticRoute: MatchedRoute<string, StaticRoute> | undefined, withEvents: WithEvents, statePath: string, routes: AppRoutes, ssr: SSRContext) => any;
 export declare const setCurrentProject: (project: string, allowedGroups: any, hostname: string) => any;
 export declare const setRoute: (path: string, state?: any) => any;
 export declare const setRouteEntry: (entry: Entry) => any;
-export declare const setSurrogateKeys: (keys: string, url: string) => any;
+export declare const setSurrogateKeys: (keys: string, url: string, status: number) => any;

package/models/routing/redux/selectors.d.ts

@@ -1,8 +1,8 @@
-import { StateType } from "../../config";
-import { AppState } from "../../redux/appstate";
+import { AppState, StateType } from "../../models";
 export declare const selectRouteEntry: (state: AppState, returnType?: StateType) => any;
 export declare const selectMappedEntry: (state: AppState, returnType?: StateType) => any;
 export declare const selectSurrogateKeys: (state: AppState) => any;
+export declare const selectSsrApiCalls: (state: AppState) => any;
 export declare const selectCurrentHostname: (state: AppState) => any;
 export declare const selectCurrentTreeID: (state: AppState) => any;
 export declare const selectRouteEntryEntryId: (state: AppState) => any;

package/models/routing/redux/types.d.ts

@@ -1,11 +1,11 @@
-export declare const GET_ENTRY: string;
-export declare const SET_ENTRY: string;
-export declare const SET_NODE: string;
-export declare const SET_ANCESTORS: string;
-export declare const SET_SIBLINGS: string;
-export declare const SET_ENTRY_ID: string;
-export declare const SET_SURROGATE_KEYS: string;
-export declare const SET_NAVIGATION_PATH: string;
-export declare const SET_TARGET_PROJECT: string;
-export declare const SET_ROUTE: string;
-export declare const UPDATE_LOADING_STATE: string;
+export declare const GET_ENTRY = "@ROUTING/_GET_ENTRY";
+export declare const SET_ENTRY = "@ROUTING/_SET_ENTRY";
+export declare const SET_NODE = "@ROUTING/_SET_NODE";
+export declare const SET_ANCESTORS = "@ROUTING/_SET_ANCESTORS";
+export declare const SET_SIBLINGS = "@ROUTING/_SET_SIBLINGS";
+export declare const SET_ENTRY_ID = "@ROUTING/_SET_ENTRY_ID";
+export declare const SET_SURROGATE_KEYS = "@ROUTING/_SET_SURROGATE_KEYS";
+export declare const SET_NAVIGATION_PATH = "@ROUTING/_SET_NAVIGATION_PATH";
+export declare const SET_TARGET_PROJECT = "@ROUTING/_SET_TARGET_PROJECT";
+export declare const SET_ROUTE = "@ROUTING/_SET_ROUTE";
+export declare const UPDATE_LOADING_STATE = "@ROUTING/_UPDATE_LOADING_STATE";

package/models/routing/routes.d.ts

@@ -1,7 +1,7 @@
 import type { RouteObject, RouteMatch } from 'react-router';
 import { Entry, Node } from 'contensis-delivery-api/lib/models';
 import React from 'react';
-import { AppState } from "../redux/appstate";
+import { AppState } from "../models";
 import { CookieHelper } from "../user/util/CookieHelper.class";
 type RouteComponent<Props> = React.ComponentType<Props>;
 export type RouteNode = Node & {

package/models/routing/util/find-contenttype-mapping.d.ts

@@ -1,2 +1,2 @@
-import { ContentTypeMapping } from '../routes';
+import { ContentTypeMapping } from "../../models";
 export declare const findContentTypeMapping: (ContentTypeMappings: ContentTypeMapping[], contentTypeId: string) => ContentTypeMapping | undefined;

package/models/routing/util/queries.d.ts

@@ -1,3 +1,3 @@
-import { VersionStatus } from 'contensis-core-api';
+import { FieldLinkDepths, VersionStatus } from 'contensis-core-api';
 import { Query } from 'contensis-delivery-api';
-export declare const routeEntryByFieldsQuery: (id: string, language?: string, fields?: string[], versionStatus?: VersionStatus) => Query;
+export declare const routeEntryByFieldsQuery: (id: string, language: string | undefined, contentTypeId: string | undefined, fields: string[] | undefined, fieldLinkDepths: FieldLinkDepths, versionStatus?: VersionStatus) => Query;

package/models/search/models/Queries.d.ts

@@ -1,4 +1,4 @@
-import { Operators, Query, VersionStatus } from 'contensis-core-api';
+import { FieldLinkDepths, Operators, Query, QueryAggregations, VersionStatus } from 'contensis-core-api';
 import { CustomWhereClause, FeaturedResults, WeightedSearchField } from './Search';
 export type FieldOperators = Exclude<keyof Operators, 'and' | 'or' | 'not'>;
 export type LogicOperators = 'and' | 'or' | 'not';
@@ -9,12 +9,14 @@ export type FilterExpression = {
     logicOperator: LogicOperators;
 };
 export type SearchQueryOptions = {
+    aggregations: QueryAggregations;
     assetTypes: string[];
     contentTypeIds: string[];
     customWhere: any;
     dynamicOrderBy: string[];
     excludeIds: string[];
     featuredResults: FeaturedResults;
+    fieldLinkDepths: FieldLinkDepths;
     fields: string[];
     filters: FilterExpression[];
     fuzzySearch?: boolean;
@@ -42,5 +44,5 @@ export type QueryParams = SearchQueryOptions & {
         [key: string]: string;
     };
 };
-export type SearchQuery = ({ contentTypeIds, customWhere, dynamicOrderBy, excludeIds, featuredResults, fields, filters, fuzzySearch, languages, pageSize, pageIndex, omitDefaultSearchFields, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryOptions, isFeatured?: boolean) => Query;
+export type SearchQuery = ({ aggregations, contentTypeIds, customWhere, dynamicOrderBy, excludeIds, featuredResults, fields, filters, fuzzySearch, languages, pageSize, pageIndex, omitDefaultSearchFields, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryOptions, isFeatured?: boolean) => Query;
 export type FilterQuery = (contentTypeIds: string[], versionStatus: VersionStatus, customWhere?: CustomWhereClause) => Query;

package/models/search/models/Search.d.ts

@@ -1,5 +1,6 @@
+import { FieldLinkDepths, QueryAggregations } from 'contensis-core-api';
 import { Entry } from 'contensis-delivery-api/lib/models';
-import MappingTemplate from 'jsonpath-mapper/dist/models/Template';
+import { MappingTemplate } from 'jsonpath-mapper';
 import { Context } from './Enums';
 import { FieldOperators, LogicOperators } from './Queries';
 import { AppState } from './SearchState';
@@ -96,11 +97,15 @@ export type SearchQueryParams = {
     assetTypes?: string[];
     /** An array of contentTypeIds to search over (sys.dataFormat == 'entry'); Prefix an entry with a "!" to exclude that content type from the search */
     contentTypeIds: string[];
+    /** Any additional field aggregations to add to the search query */
+    customAggregations?: QueryAggregations;
     /** An array of CustomWhereClause to include in the search query */
     customWhere?: CustomWhereClause;
     /** Add parameters to drive an additional set of featured results */
     featuredResults?: FeaturedResults;
     /** An array of fields to return for each entry in the items[] */
+    fieldLinkDepths?: FieldLinkDepths;
+    /** An array of fields to return for each entry in the items[] */
     fields?: string[];
     /** Allows a “fuzzy” search (defaults to `false`) */
     fuzzySearch?: boolean;
@@ -120,6 +125,8 @@ export type SearchQueryParams = {
     pageSize?: number;
     /** Allow a configured minilist to read the search.term set in state (defaults to false) */
     useSearchTerm?: boolean;
+    /** Allow overriding of versionStatus, irrespective of environment */
+    versionStatus?: 'latest' | 'published';
     /** An array of webpageTemplates to search over (sys.dataFormat == 'webpage'); Prefix an entry with a "!" to exclude that webpage template from the search */
     webpageTemplates?: string[];
     /** An array of WeightedSearchField to include in the search query */