@zengenti/contensis-react-base 4.0.0-beta.8 → 4.0.0

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

@@ -1,17 +1,27 @@
 import { Context } from '../models/Enums';
 import { QueryParams as QueryParams2 } from '../models/Queries';
 import { CustomApi, SearchQueryParams } from '../models/Search';
-import { AppState, Facet, Facets, Filters, Paging, SelectedFilters, Tab } from '../models/SearchState';
+import { AppState, Composition, Facet, Facets, Filters, Paging, SearchState, SelectedFilters, Tab } from '../models/SearchState';
 type StateType = 'immutable' | 'js';
-export declare const getSearchContext: (state: AppState) => Context;
-export declare const getCurrent: (state: AppState, context?: Context) => string;
+type ContextType = keyof typeof Context;
+export declare const getSearchContext: (state: AppState) => ContextType;
+export declare const getCurrent: (state: AppState, context?: ContextType) => string;
 export declare const getCurrentFacet: (state: AppState) => string;
 export declare const getCurrentListing: (state: AppState) => string;
 export declare const getCurrentTab: (state: AppState) => number;
+export declare const getCurrentComposition: (state: AppState) => string;
+/** A localised version of `getCurrent` selector */
+export declare const getLocalisedCurrent: (state: AppState, language?: string, context?: ContextType) => string;
+export declare const getLocalisedFacetKey: (state: AppState, facet?: string, language?: string, context?: ContextType) => string | undefined;
+export declare const getCurrentFromLocalised: (state: AppState, alias: string, language?: string, context?: ContextType) => {
+    facet: string;
+    language: string;
+} | null;
 export declare const getFacets: (state: AppState, returnType?: StateType) => Facets;
 export declare const getTabFacets: (state: AppState) => {
     [k: string]: Facet;
 };
+export declare const getCompositionFacets: (state: AppState, composition?: string) => Facets;
 export declare const getFacetTitles: (state: AppState) => {
     isSelected: boolean;
     key: string;
@@ -20,41 +30,54 @@ export declare const getFacetTitles: (state: AppState) => {
 }[];
 export declare const getFacet: (state: AppState, facetName?: string, context?: Context | string, returnType?: StateType) => Facet;
 export declare const getListing: (state: AppState, listing?: string) => Facet;
-export declare const getFilters: (state: AppState, facet: string, context?: Context, returnType?: StateType) => Filters;
-export declare const getRenderableFilters: (state: AppState, facet?: string, context?: Context) => Filters;
-export declare const getFiltersToLoad: (state: AppState, facet: string, context?: Context, returnType?: StateType) => string[];
-export declare const getSelectedFilters: (state: AppState, facet?: string, context?: Context, returnType?: StateType) => SelectedFilters;
-export declare const getResults: (state: AppState, current?: string, context?: Context, returnType?: StateType) => any[];
-export declare const getIsInternalPaging: (state: AppState, current: string, context?: Context) => boolean;
-export declare const getIsLoaded: (state: AppState, context?: Context, facet?: string) => boolean;
-export declare const getIsLoading: (state: AppState, context?: Context, facet?: string) => boolean;
+export declare const getComposition: (state: AppState, composition?: string) => Composition & {
+    listings?: Facets;
+    facets?: Facets;
+};
+/** Return filter state for the current (or provided) facet */
+export declare const getFilters: (state: AppState, facet: string, context?: ContextType, returnType?: StateType) => Filters;
+export declare const getLocalisedFilterKey: (state: AppState, key: string, language: string | undefined, facet: string, context?: ContextType) => string;
+export declare const getFilterKeyFromLocalised: (state: AppState, key: string, language: string | undefined, facet: string, context?: ContextType) => string;
+/** Return filter state for the current (or provided) facet, excluding filters configured as `renderable: false` */
+export declare const getRenderableFilters: (state: AppState, facet?: string, context?: ContextType) => Filters;
+export declare const getFiltersToLoad: (state: AppState, facet: string, context?: ContextType, returnType?: StateType) => string[];
+/** Return keyed object for all filters in the current facet with all selected values for each filter */
+export declare const getSelectedFilters: (state: AppState, facet?: string, context?: ContextType, returnType?: StateType) => SelectedFilters;
+/** Return keyed object for all _renderable_ filters in the current facet with all selected values for each filter */
+export declare const getRenderableSelectedFilters: (state: AppState, facet?: string, context?: ContextType) => SelectedFilters;
+/** A localised version of `getRenderableSelectedFilters` selector */
+export declare const getLocalisedRenderableSelectedFilters: (state: AppState, facet?: string, context?: ContextType) => SelectedFilters;
+export declare const getResults: (state: AppState, current?: string, context?: ContextType, returnType?: StateType) => any[];
+export declare const getResultsInfo: (state: AppState, current?: string, context?: ContextType) => any;
+export declare const getIsInternalPaging: (state: AppState, current: string, context?: ContextType) => boolean;
+export declare const getIsLoaded: (state: AppState, context?: ContextType, facet?: string) => boolean;
+export declare const getIsLoading: (state: AppState, context?: ContextType, facet?: string) => boolean;
 export declare const getIsSsr: (state: AppState) => boolean;
-export declare const getFeaturedResults: (state: AppState, current?: string, context?: Context, returnType?: StateType) => any[];
-export declare const getPaging: (state: AppState, current?: string, context?: Context, returnType?: StateType) => Paging;
-export declare const getPageIndex: (state: AppState, current?: string, context?: Context) => number;
-export declare const getPageSize: (state: AppState, current?: string, context?: Context) => number;
-export declare const getPrevPageIndex: (state: AppState, current?: string, context?: Context) => number;
-export declare const getPageIsLoading: (state: AppState, current?: string, context?: Context) => boolean;
-export declare const getPagesLoaded: (state: AppState, current?: string, context?: Context) => number[];
-export declare const getTotalCount: (state: AppState, current?: string, context?: Context) => number;
+export declare const getFeaturedResults: (state: AppState, current?: string, context?: ContextType, returnType?: StateType) => any[];
+export declare const getPaging: (state: AppState, current?: string, context?: ContextType, returnType?: StateType) => Paging;
+export declare const getPageIndex: (state: AppState, current?: string, context?: ContextType) => number;
+export declare const getPageSize: (state: AppState, current?: string, context?: ContextType) => number;
+export declare const getPrevPageIndex: (state: AppState, current?: string, context?: ContextType) => number;
+export declare const getPageIsLoading: (state: AppState, current?: string, context?: ContextType) => boolean;
+export declare const getPagesLoaded: (state: AppState, current?: string, context?: ContextType) => number[];
+export declare const getTotalCount: (state: AppState, current?: string, context?: ContextType) => number;
 export declare const getSearchTerm: (state: AppState) => string;
 export declare const getSearchTabs: (state: AppState, returnType?: StateType) => Tab[];
-export declare const getQueryParams: (state: AppState, current?: string, context?: Context) => Record<string, any>;
-export declare const getQueryParameter: <K extends keyof SearchQueryParams, K2 extends "projectId" | "linkDepth" | "internalPaging" | "loadMorePaging" | keyof import("../models/Queries").SearchQueryOptions | "env" | "internalPageIndex" | "pagesLoaded" | "prevPageIndex" | "selectedFilters">({ state, facet, context, }: {
+export declare const getSearchCompositions: (state: AppState) => SearchState["compositions"];
+export declare const getQueryParams: (state: AppState, current?: string, context?: ContextType) => Record<string, any>;
+export declare const getQueryParameter: <K extends keyof SearchQueryParams, K2 extends keyof QueryParams2>({ state, facet, context, }: {
     state: AppState;
     facet?: string;
-    context?: Context;
+    context?: ContextType;
 }, key: K | K2, ifnull?: any) => SearchQueryParams[K] | QueryParams2[K2];
-export declare const getCustomApi: (state: AppState, current: string, context?: Context, returnType?: StateType) => CustomApi;
-export declare const getCustomEnv: (state: AppState, current: string, context?: Context) => any;
+export declare const getCustomApi: (state: AppState, current: string, context?: ContextType, returnType?: StateType) => CustomApi;
 export declare const getTabsAndFacets: (state: AppState, returnType?: StateType) => any;
 export declare const getSearchTotalCount: (state: AppState) => number;
 export declare const getFacetsTotalCount: (state: AppState) => number;
 export declare const selectFacets: {
     getCurrent: (state: AppState) => string;
     getCurrentTab: (state: AppState) => number;
-    getCustomApi: (state: AppState, current: string, context?: Context, returnType?: StateType) => CustomApi;
-    getCustomEnv: (state: AppState, current: string, context?: Context) => any;
+    getCustomApi: (state: AppState, current: string, context?: ContextType, returnType?: StateType) => CustomApi;
     getFacet: (state: AppState, facetName?: string, context?: Context | string, returnType?: StateType) => Facet;
     getFacetTitles: (state: AppState) => {
         isSelected: boolean;
@@ -64,31 +87,32 @@ export declare const selectFacets: {
     }[];
     getFacets: (state: AppState, returnType?: StateType) => Facets;
     getFacetsTotalCount: (state: AppState) => number;
-    getFeaturedResults: (state: AppState, current?: string, context?: Context, returnType?: StateType) => any[];
-    getFilters: (state: AppState, facet: string, context?: Context, returnType?: StateType) => Filters;
-    getFiltersToLoad: (state: AppState, facet: string, context?: Context, returnType?: StateType) => string[];
-    getIsLoaded: (state: AppState, context?: Context, facet?: string) => boolean;
-    getIsLoading: (state: AppState, context?: Context, facet?: string) => boolean;
-    getPageIndex: (state: AppState, current?: string, context?: Context) => number;
-    getPageIsLoading: (state: AppState, current?: string, context?: Context) => boolean;
-    getPagesLoaded: (state: AppState, current?: string, context?: Context) => number[];
-    getPaging: (state: AppState, current?: string, context?: Context, returnType?: StateType) => Paging;
+    getFeaturedResults: (state: AppState, current?: string, context?: ContextType, returnType?: StateType) => any[];
+    getFilters: (state: AppState, facet: string, context?: ContextType, returnType?: StateType) => Filters;
+    getFiltersToLoad: (state: AppState, facet: string, context?: ContextType, returnType?: StateType) => string[];
+    getIsLoaded: (state: AppState, context?: ContextType, facet?: string) => boolean;
+    getIsLoading: (state: AppState, context?: ContextType, facet?: string) => boolean;
+    getLocalisedCurrent: (state: AppState) => string;
+    getPageIndex: (state: AppState, current?: string, context?: ContextType) => number;
+    getPageIsLoading: (state: AppState, current?: string, context?: ContextType) => boolean;
+    getPagesLoaded: (state: AppState, current?: string, context?: ContextType) => number[];
+    getPaging: (state: AppState, current?: string, context?: ContextType, returnType?: StateType) => Paging;
     getQueryParams: (state: AppState, facet: string) => Record<string, any>;
     getQueryParameter: ({ state, facet }: {
         state: AppState;
         facet?: string;
     }, key: keyof SearchQueryParams | keyof QueryParams2, ifnull: any) => any;
-    getRenderableFilters: (state: AppState, facet?: string, context?: Context) => Filters;
-    getResults: (state: AppState, current?: string, context?: Context, returnType?: StateType) => any[];
+    getRenderableFilters: (state: AppState, facet?: string, context?: ContextType) => Filters;
+    getResults: (state: AppState, current?: string, context?: ContextType, returnType?: StateType) => any[];
     getTabFacets: (state: AppState) => {
         [k: string]: Facet;
     };
     getTabsAndFacets: (state: AppState, returnType?: StateType) => any;
-    getTotalCount: (state: AppState, current?: string, context?: Context) => number;
+    getTotalCount: (state: AppState, current?: string, context?: ContextType) => number;
     getSearchTabs: (state: AppState, returnType?: StateType) => Tab[];
     getSearchTerm: (state: AppState) => string;
     getSearchTotalCount: (state: AppState) => number;
-    getSelectedFilters: (state: AppState, facet?: string, context?: Context, returnType?: StateType) => SelectedFilters;
+    getSelectedFilters: (state: AppState, facet?: string, context?: ContextType, returnType?: StateType) => SelectedFilters;
 };
 export declare const selectListing: {
     getCurrent: (state: AppState) => string;
@@ -96,6 +120,7 @@ export declare const selectListing: {
     getFilters: (state: AppState, listing?: string) => Filters;
     getFiltersToLoad: (state: AppState, listing?: string) => string[];
     getListing: (state: AppState, listing?: string) => Facet;
+    getLocalisedCurrent: (state: AppState) => string;
     getIsLoaded: (state: AppState) => boolean;
     getIsLoading: (state: AppState) => boolean;
     getPageIndex: (state: AppState, listing?: string) => number;
@@ -113,7 +138,4 @@ export declare const selectListing: {
     getTotalCount: (state: AppState, listing?: string) => number;
     getSelectedFilters: (state: AppState, listing?: string) => SelectedFilters;
 };
-export declare const selectCurrentPath: (state: AppState) => any;
-export declare const selectCurrentProject: (state: AppState) => any;
-export declare const selectVersionStatus: (state: AppState) => any;
 export {};

package/models/search/redux/util.d.ts

@@ -1,6 +1,6 @@
 import { SearchQueryOptions } from '../models/Queries';
 import { AppState } from '../models/SearchState';
-import { EnsureSearchAction, SetSearchEntriesAction } from '../models/SearchActions';
+import { EnsureSearchAction, SearchParams, SetSearchEntriesAction } from '../models/SearchActions';
 /**
  * 1, Generates all the parameters required to run the search query.
  * 2, Tells us if we should run the search.
@@ -15,6 +15,14 @@ export declare const generateQueryParams: (action: EnsureSearchAction | SetSearc
  * @param state
  */
 export declare const runSearch: (action: EnsureSearchAction | SetSearchEntriesAction, state: AppState, queryParams: SearchQueryOptions) => boolean;
+/**
+ * Patch mutates original params argument to decode certain
+ * url encoded params which can creep into urls and cause a
+ * flash of different content when hydrating from SSR
+ * @param params SearchParams
+ * @returns SearchParams
+ */
+export declare const sanitiseParams: (params?: SearchParams) => SearchParams | undefined;
 /**
  * This will tell us if filter parameters have been
  * changed by some external event such as a route change
@@ -22,5 +30,6 @@ export declare const runSearch: (action: EnsureSearchAction | SetSearchEntriesAc
  * @returns true or false
  */
 export declare const filterParamsChanged: (action: EnsureSearchAction | SetSearchEntriesAction, state?: AppState) => boolean;
+export declare const languageChanged: (action: EnsureSearchAction | SetSearchEntriesAction) => boolean;
 export declare const debugExecuteSearch: (action: EnsureSearchAction | SetSearchEntriesAction, state: AppState) => void;
 export declare const scrollTo: (scrollToElement: string) => void;

package/models/search/search/ContensisDeliveryApi.d.ts

@@ -1,33 +1,13 @@
-export * from "contensis-delivery-api";
-export function GetClientSideDeliveryApiStatus(): "published" | "latest" | null;
-export function GetDeliveryApiStatusFromHostname(currentHostname: any): "published" | "latest";
-export const deliveryApi: DeliveryApi;
-export const cachedSearch: CachedSearch;
-declare class DeliveryApi {
-    search(query: any, linkDepth: any, project: any, env: any): Promise<import("contensis-core-api").PagedList<import("contensis-delivery-api").Entry>>;
-    getClient(deliveryApiStatus: string | undefined, project: any, env: any): Client;
-    getEntry(id: any, linkDepth: number | undefined, deliveryApiStatus: string | undefined, project: any, env: any): Promise<import("contensis-delivery-api").Entry>;
-}
-declare class CachedSearch {
+/** @deprecated Taxonomy is deprecated in Contensis, code remains
+ * to support any legacy implementations using Taxonomy in their search */
+export const cachedTaxonomyLookup: CachedTaxonomyLookup;
+declare class CachedTaxonomyLookup {
     cache: LruCache;
     taxonomyLookup: {};
-    search(query: any, linkDepth: any, project: any, env: any): any;
     getTaxonomyNodeByPath(path: any, project: any, env: any): any;
     request(key: any, execute: any): any;
     extendTaxonomyNode(node: any): any;
     getTaxonomyId(node: any): any;
-    fetch(uri: any, opts?: {}): any;
-}
-import { Client } from 'contensis-delivery-api';
-declare class LruCache {
-    constructor(limit?: number);
-    map: {};
-    head: any;
-    tail: any;
-    limit: number;
-    size: number;
-    get(key: any): any;
-    set(key: any, value: any): void;
-    setHead(node: any): void;
-    remove(key: any): void;
 }
+import { LruCache } from "../../util/LruCache";
+export {};

package/models/search/search/expressions.d.ts

@@ -1,10 +1,12 @@
-import { ContensisQueryOrderBy, IExpression, ILogicalExpression, VersionStatus } from 'contensis-core-api';
+import { ContensisQueryOrderBy, IExpression, VersionStatus } from 'contensis-core-api';
 import { CustomWhereClause, WeightedSearchField } from '../models/Search';
 import { FieldOperators, FilterExpression } from '../models/Queries';
 export declare const fieldExpression: (field: string | string[], value: any, operator?: FieldOperators, weight?: number, fuzzySearch?: boolean) => IExpression[];
-export declare const contentTypeIdExpression: (contentTypeIds: string[], webpageTemplates?: string[], assetTypes?: string[]) => ILogicalExpression[];
+export declare const contentTypeIdExpression: (contentTypeIds: string[], webpageTemplates?: string[], assetTypes?: string[]) => IExpression[];
 export declare const filterExpressions: (filters: FilterExpression[], isOptional?: boolean) => IExpression[];
-export declare const dataFormatExpression: (contentTypeIds: string[], dataFormat?: string) => ILogicalExpression[];
+/** @deprecated since v4 - contentTypeIdExpression produces a simpler more efficient query
+ * now and negates the need for supplying `sys.dataFormat` with `sys.contentTypeId` */
+export declare const dataFormatExpression: (contentTypeIds: string[], dataFormat?: string) => import("contensis-core-api").ILogicalExpression[];
 export declare const featuredResultsExpression: ({ contentTypeId, fieldId, fieldValue, }?: {
     contentTypeId?: string | string[];
     fieldId?: string | string[];
@@ -14,7 +16,7 @@ export declare const languagesExpression: (languages: string[]) => IExpression[]
 export declare const includeInSearchExpressions: (webpageTemplates: string[], includeInSearchFields: string[]) => IExpression[];
 export declare const defaultExpressions: (versionStatus: VersionStatus) => IExpression[];
 export declare const includeIdsExpression: (includeIds: string[]) => IExpression[];
-export declare const excludeIdsExpression: (excludeIds: string[]) => ILogicalExpression[];
+export declare const excludeIdsExpression: (excludeIds: string[]) => import("contensis-core-api").ILogicalExpression[];
 export declare const orderByExpression: (orderBy: string[]) => ContensisQueryOrderBy;
 /**
  * Accept HTTP style objects and map them to

package/models/search/search/util.d.ts

@@ -2,6 +2,8 @@ import { Entry } from 'contensis-delivery-api/lib/models';
 import { PagedList, Query } from 'contensis-core-api';
 import { CustomApi } from '../models/Search';
 import { TimedSearchResponse } from '../models/SearchUtil';
+import { SearchParams } from '../models/SearchActions';
+import { CachedSearch } from "../../util/ContensisDeliveryApi";
 export declare function fixFreeTextForElastic(s: string): string;
 /** `convertKeyForAggregation` and `parseKeyForAggregation` exists to prevent an
  *  auto-generated aggregation using a reserved keyword because Elasticsearch has a list of
@@ -17,16 +19,16 @@ export declare function fixFreeTextForElastic(s: string): string;
  */
 export declare const convertKeyForAggregation: (key: string) => string;
 export declare const parseKeyForAggregation: (key: string) => string;
-export declare const convertFieldIdForAggregation: (fieldId: string) => string;
-export declare const timedSearch: (query: Query, linkDepth?: number, projectId?: string, env?: string) => Promise<null | TimedSearchResponse>;
+export declare const cleanseFieldIdForAggregation: (fieldId: string) => string;
+export declare const timedSearch: (query: Query, linkDepth?: number, projectId?: string, ssr?: {
+    api: CachedSearch;
+}) => Promise<null | TimedSearchResponse>;
 export declare const getItemsFromResult: (result?: {
     duration: number;
     payload: PagedList<Entry> | any[];
 }) => Entry[];
 export declare const extractQuotedPhrases: (searchTerm: string) => string[];
-export declare const buildUrl: (route: string, params: {
-    [key: string]: string;
-}) => string;
+export declare const buildUrl: (route: string, params: SearchParams) => string;
 /**
  * Returns all params from the current route query string or static route
  * Supply static route argument if reading parameters from the route path
@@ -41,8 +43,8 @@ export declare const routeParams: (staticRoute?: any, location?: {
     search: string;
     hash?: string;
 }) => any;
-export declare const callCustomApi: <T>(customApi: CustomApi, filters: {
-    [key: string]: string;
+export declare const callCustomApi: <T>(customApi: CustomApi, filters: SearchParams, ssr?: {
+    api: CachedSearch;
 }) => Promise<T>;
 export declare const removeEmptyAttributes: (obj: any) => any;
 export declare const toArray: (obj: string | null, seperator?: string) => string[] | null;

package/models/search/transformations/state-to-queryparams.mapper.d.ts

@@ -3,7 +3,7 @@ import { AppState } from '../models/SearchState';
 import { Context } from '../models/Enums';
 import { EnsureSearchAction, SetSearchEntriesAction } from '../models/SearchActions';
 type QueryParamsMapperParams = {
-    context: Context;
+    context: keyof typeof Context | Context;
     facet: string;
     action: EnsureSearchAction | SetSearchEntriesAction;
     state: AppState;

package/models/server/features/linkdepth-api/search.d.ts

@@ -14,7 +14,7 @@ type SearchQueryArgs = WithOptional<SearchQueryOptions & {
  */
 export declare const searchQuery: ({ assetTypes, contentTypeIds, customWhere, fields, filters, idFilters, sharedFilters, pageSize, pageIndex, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryArgs) => Query;
 export declare const appendSearchQueryFilters: (query: Query, idFilters: FilterExpression[]) => void;
-export declare const finalQuery: ({ assetTypes, contentTypeIds, fields, filters, idFilters, sharedFilters, pageSize, pageIndex, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryArgs, children: Omit<SearchQueryArgs, 'pageSize' | 'pageIndex' | 'versionStatus'>[]) => Query;
+export declare const finalQuery: ({ assetTypes, contentTypeIds, fields, filters, idFilters, sharedFilters, pageSize, pageIndex, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryArgs, children: Omit<SearchQueryArgs, "pageSize" | "pageIndex" | "versionStatus">[]) => Query;
 /**
  * Create a filter expression from a provided filters configuration object
  * and populate them based on the presence of that key in params, filter

package/models/server/features/response-handler/render-stream.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import { Response } from 'express';
+import { Request, Response } from 'express';
 import { ReactNode } from 'react';
 import { Transform, Writable } from 'stream';
 import { ServerStyleSheet } from 'styled-components';
@@ -11,7 +10,7 @@ import { ServerStyleSheet } from 'styled-components';
  * @param response the express Response object
  * @param stream all chunks are piped to this stream to add additional style elements to each streamed chunk
  */
-export declare const renderStream: (getContextHtml: (isFinal?: boolean) => string, jsx: ReactNode, response: Response, stream: Writable) => void;
+export declare const renderStream: (getContextHtml: (isFinal?: boolean) => string, jsx: ReactNode, request: Request, response: Response, stream: Writable) => void;
 /**
  * Generate and add styled-components CSS to the streamed
  * chunks of rendered HTML via renderToPipeableStream
@@ -23,4 +22,3 @@ export declare const renderStream: (getContextHtml: (isFinal?: boolean) => strin
  * @returns Transform Stream
  */
 export declare const styledComponentsStream: (sheet: ServerStyleSheet) => Transform;
-export declare const renderToString: () => void;

package/models/server/features/static-assets/index.d.ts

@@ -1,10 +1,11 @@
-declare const staticAssets: (app: any, { appRootPath, scripts, startupScriptFilename, staticFolderPath, staticRoutePath, staticRoutePaths, }: {
+import express from 'express';
+declare const staticAssets: (app: express.Express, { appRootPath, scripts, startupScriptFilename, staticFolderPath, staticRoutePath, staticRoutePaths, }: {
     appRootPath?: string | undefined;
     scripts?: {
         attributes?: {
             [key: string]: string;
-        } | undefined;
-        startup?: string | undefined;
+        };
+        startup?: string;
     } | undefined;
     startupScriptFilename?: string | undefined;
     staticFolderPath?: string | undefined;

package/models/server/internalServer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import 'isomorphic-fetch';
 import { Express } from 'express';
 import http from 'http';
@@ -9,7 +8,7 @@ type Exporting = {
     app: Express;
     apiProxy: typeof deliveryProxy;
     server: http.Server;
-    start: (ReactApp: React.ComponentType<any>, config: ServerConfig, ServerFeatures: (app: Express) => void) => void;
+    start: (ReactApp: React.ComponentType<any>, config: ServerConfig, ServerFeatures: (app: Express) => void | null | undefined) => void;
 };
 declare const _default: Exporting;
 export default _default;

package/models/server/middleware/subsiteDebug.d.ts

@@ -0,0 +1,11 @@
+import { RequestHandler } from 'express';
+/**
+ * Development proxy for Subsite PoC
+ * Catch all routes before they hit CRB handlers
+ * and rewrite them to include the subsite base path,
+ * this allows us to run the subsite in a subfolder in development
+ * In production we will handle this with a path rewrite in the Cloud Dashboard site configuration,
+ * @param subsitePath the content base path we will rewrite to
+ * @param exceptions an array of path prefixes to ignore when rewriting, useful for ignoring assets that do not live in the subsite base path
+ */
+export declare const subsiteDebugMiddleware: (subsitePath: string, exceptions?: string[]) => RequestHandler;

package/models/server/root.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const DocumentRoot: ({ children }: React.PropsWithChildren<any>) => React.JSX.Element;
+export default DocumentRoot;

package/models/server/util/bundles.d.ts

@@ -1,12 +1,12 @@
 import { ChunkExtractor } from '@loadable/server';
 import { ServerConfig } from "../../models";
 export declare const loadableBundleData: ({ stats, templates }: ServerConfig, staticRoutePath: string, build?: string) => {
-    stats?: string | null | undefined;
+    stats?: string | null;
     templates?: {
         templateHTML: string;
         templateHTMLStatic: string;
         templateHTMLFragment: string;
-    } | null | undefined;
+    } | null;
 };
 type LoadableChunkExtractors = {
     legacy?: ChunkExtractor;
@@ -16,29 +16,29 @@ type LoadableChunkExtractors = {
 export declare const loadableChunkExtractors: () => LoadableChunkExtractors;
 export declare const getBundleData: (config: ServerConfig, staticRoutePath: string) => {
     default: {
-        stats?: string | null | undefined;
+        stats?: string | null;
         templates?: {
             templateHTML: string;
             templateHTMLStatic: string;
             templateHTMLFragment: string;
-        } | null | undefined;
+        } | null;
     };
     legacy: {
-        stats?: string | null | undefined;
+        stats?: string | null;
         templates?: {
             templateHTML: string;
             templateHTMLStatic: string;
             templateHTMLFragment: string;
-        } | null | undefined;
+        } | null;
     };
     modern: {
-        stats?: string | null | undefined;
+        stats?: string | null;
         templates?: {
             templateHTML: string;
             templateHTMLStatic: string;
             templateHTMLFragment: string;
-        } | null | undefined;
+        } | null;
     };
 };
-export declare const getBundleTags: (loadableExtractor: LoadableChunkExtractors, scripts: ServerConfig['scripts'], staticRoutePath?: string) => string;
+export declare const getBundleTags: (loadableExtractor: LoadableChunkExtractors, scripts: ServerConfig["scripts"], staticRoutePath?: string) => string;
 export {};

package/models/server/util/jsx.d.ts

@@ -13,13 +13,14 @@ import { HttpContextValues } from "../../routing/httpContext";
  * @param { providers, props, ssrAssets }
  * @returns the final JSX to render decorated with all Provider and App props
  */
-export declare const ssrJsxProducer: (ReactApp: React.ComponentType<any>, { providers, props, ssrAssets, }: {
+export declare const ssrJsxProducer: (ReactApp: React.ComponentType<any>, { providers, props, }: {
     /** Providers enrich the JSX */
     providers: {
         loadable: {
             extractor: ChunkExtractor;
         };
         cookies?: Cookies;
+        helmet: Record<string, unknown>;
         redux: typeof reduxStore;
         httpContext: HttpContextValues;
         router: {
@@ -39,17 +40,4 @@ export declare const ssrJsxProducer: (ReactApp: React.ComponentType<any>, { prov
         routes: AppRoutes;
         withEvents: WithEvents;
     };
-    /**
-     * SSR Assets are passed in here when they become available
-     * allowing the ReactApp to control the render for the
-     * entire HTML document
-     */
-    ssrAssets?: {
-        bundleTags?: string;
-        htmlAttributes?: string;
-        metadata?: string;
-        serializedState?: string;
-        styleTags?: string;
-        title?: string;
-    };
 }) => React.JSX.Element;

package/models/user/components.styled/Login.styled.d.ts

@@ -1,2 +1,2 @@
 export default LoginStyled;
-declare const LoginStyled: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+declare const LoginStyled: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;

package/models/user/components.styled/LoginForm.styled.d.ts

@@ -1,2 +1,2 @@
 export default LoginFormStyled;
-declare const LoginFormStyled: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+declare const LoginFormStyled: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;

package/models/user/hocs/withRegistration.d.ts

@@ -5,5 +5,5 @@ declare function withRegistration(WrappedComponent: any): import("react-redux").
     [x: string]: any;
     [x: number]: any;
     context?: import("react").Context<import("react-redux").ReactReduxContextValue<any, import("../../../node_modules/redux").UnknownAction> | null> | undefined;
-    store?: import("../../../node_modules/redux").Store<any, import("../../../node_modules/redux").UnknownAction, unknown> | undefined;
+    store?: import("../../../node_modules/redux").Store | undefined;
 }>;

package/models/util/CachedDeliveryApi.d.ts

@@ -4,7 +4,7 @@ import { INodeOperations, NodeGetRootOptions } from 'contensis-delivery-api/lib/
 import { DeliveryApi, SSRContext } from './ContensisDeliveryApi';
 import { LruCache } from './LruCache';
 import { CookieObject } from "../user/util/CookieConstants";
-declare class CachedSearch {
+export declare class CachedSearch {
     cache: LruCache;
     cookies?: CookieObject;
     ssr?: SSRContext;
@@ -20,7 +20,13 @@ declare class CachedSearch {
     getChildren(options: Parameters<INodeOperations['getChildren']>[0], project?: string): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
     getSiblings(options: Parameters<INodeOperations['getSiblings']>[0], project?: string): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
     request<T extends () => Promise<any>>(key: string, execute: T): ReturnType<T>;
+    /** Use the cached API for fetch requests */
+    fetch(uri: RequestInfo, opts?: RequestInit): Promise<Response>;
 }
 export declare const cachedSearch: CachedSearch;
+/** Create a cached search instance attached to the current environment
+ * SSR context and connected to your environment via global variable
+ * `DELIVERY_API_CONFIG`  */
+export declare const cachedSearchWithContext: (ssr?: SSRContext) => CachedSearch;
+/** @deprecated Use cachedSearchWithContext instead */
 export declare const cachedSearchWithCookies: (ssr?: SSRContext) => CachedSearch;
-export {};

package/models/util/ContensisDeliveryApi.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" />
 import { VersionStatus } from 'contensis-core-api';
-import { Client, Query } from 'contensis-delivery-api';
-import { Config } from 'contensis-delivery-api/lib/models';
+import { Client, Config, Query } from 'contensis-delivery-api';
 import { CookieObject } from "../user/util/CookieConstants";
 import { Request } from 'express';
 import { IncomingHttpHeaders } from 'http';
@@ -13,7 +11,7 @@ export declare class DeliveryApi {
     ssr?: SSRContext;
     constructor(ssr?: SSRContext);
     getClientSideVersionStatus: () => any;
-    getServerSideVersionStatus: (request: Request) => string | import("qs").ParsedQs | (string | import("qs").ParsedQs)[];
+    getServerSideVersionStatus: (request: Request) => "published" | "latest" | undefined;
     getVersionStatusFromHeaders: (headers: IncomingHttpHeaders) => string | string[] | null;
     getVersionStatusFromHostname: (currentHostname: string) => "published" | "latest";
     search: (query: Query, linkDepth?: number, project?: string) => Promise<import("contensis-core-api").PagedSearchList<import("contensis-delivery-api").Entry>>;

package/models/util/NoSSR.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/**
+ * NoSSR component to prevent children from rendering on the server.
+ * Renders children only after component has mounted in the browser.
+ */
+export declare const NoSSR: React.FC<React.PropsWithChildren>;

package/models/util/SSRContext.d.ts

@@ -1,6 +1,6 @@
 import { Request, Response } from 'express';
 import React, { PropsWithChildren } from 'react';
-import { SSRAccessMethod, SSRAssets, SSRContext as SSRContextType } from "../models";
+import { SSRAccessMethod, SSRContext as SSRContextType } from "../models";
 /**
  * SSRContextProvider allows us to hold and access request-scoped references
  * throughout the component tree
@@ -8,11 +8,10 @@ import { SSRAccessMethod, SSRAssets, SSRContext as SSRContextType } from "../mod
  * adding this in client side allows consumers to write universal code and use
  * the same helpers and request-scoped refs for api, cookies and redux dispatcher
  * as in SSR */
-export declare const SSRContextProvider: ({ accessMethod, children, request, response, ssrAssets, }: PropsWithChildren<{
+export declare const SSRContextProvider: ({ accessMethod, children, request, response, }: PropsWithChildren<{
     accessMethod?: SSRAccessMethod;
     request?: Request;
     response?: Response;
-    ssrAssets?: SSRAssets;
 }>) => React.JSX.Element;
 /**
  * Server side usage provides access to request-scoped references throughout the component tree
@@ -22,19 +21,4 @@ export declare const SSRContextProvider: ({ accessMethod, children, request, res
  * @returns SSRContextType
  */
 export declare const useSSRContext: () => SSRContextType;
-export declare const useDeliveryApi: () => {
-    cache: import("./LruCache").LruCache;
-    cookies?: import("../user/util/CookieConstants").CookieObject | undefined;
-    ssr?: import("./ContensisDeliveryApi").SSRContext | undefined;
-    getClient(versionStatus?: import("contensis-core-api").VersionStatus | undefined, project?: string | undefined): import("contensis-delivery-api").Client;
-    search(query: import("contensis-core-api").Query, linkDepth?: number, project?: string | undefined): Promise<import("contensis-core-api").PagedSearchList<import("contensis-delivery-api").Entry>>;
-    searchUsingPost(query: import("contensis-core-api").Query, linkDepth?: number, project?: string): any;
-    get(id: string, linkDepth?: number, versionStatus?: import("contensis-core-api").VersionStatus, project?: string | undefined, fields?: string[] | undefined): Promise<import("contensis-delivery-api").Entry>;
-    getContentType(id: string, project?: string | undefined): Promise<import("contensis-core-api").ContentType>;
-    getRootNode(options: import("contensis-delivery-api").NodeGetRootOptions, versionStatus?: import("contensis-core-api").VersionStatus, project?: string | undefined): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>>;
-    getNode(options: string | import("contensis-delivery-api").NodeGetByIdOptions | import("contensis-delivery-api").NodeGetByPathOptions, project?: string | undefined): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>>;
-    getAncestors(options: string | import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry> | import("contensis-delivery-api").NodeGetAncestorsOptions, project?: string | undefined): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
-    getChildren(options: string | import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry> | import("contensis-delivery-api").NodeGetChildrenOptions, project?: string | undefined): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
-    getSiblings(options: string | import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry> | import("contensis-delivery-api").NodeGetSiblingOptions, project?: string | undefined): Promise<import("contensis-delivery-api").Node<import("contensis-delivery-api").Entry>[]>;
-    request<T extends () => Promise<any>>(key: string, execute: T): ReturnType<T>;
-};
+export declare const useDeliveryApi: () => import("./CachedDeliveryApi").CachedSearch;

package/models/util/donotuse_useHistory.d.ts

@@ -0,0 +1,6 @@
+/** @deprecated ponyfill for useHistory hook in react-router v5 removed in v6 */
+export declare const useHistory: () => {
+    push: import("react-router-dom").NavigateFunction;
+    replace: import("react-router-dom").NavigateFunction;
+    location: import("react-router-dom").Location<any>;
+};