@zengenti/contensis-react-base 2.4.1-beta.9 → 2.5.0

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

@@ -0,0 +1,43 @@
+import { Query } from 'contensis-core-api';
+import { VersionStatus } from 'contensis-core-api/lib/models';
+import { Operators } from 'contensis-delivery-api/lib/entries/query';
+import { CustomWhereClause, FeaturedResults, WeightedSearchField } from './Search';
+export declare type FieldOperators = Exclude<keyof Operators, 'and' | 'or' | 'not'>;
+export declare type SearchQueryOptions = {
+    assetTypes: string[];
+    contentTypeIds: string[];
+    customWhere: any;
+    dynamicOrderBy: string[];
+    excludeIds: string[];
+    featuredResults: FeaturedResults;
+    fields: string[];
+    filters: {
+        key: string;
+        value: string;
+        operator: FieldOperators;
+    }[];
+    includeInSearchFields: string[];
+    languages: string[];
+    pageSize: number;
+    pageIndex: number;
+    orderBy: string[];
+    searchTerm: string;
+    versionStatus: VersionStatus;
+    webpageTemplates: string[];
+    weightedSearchFields: WeightedSearchField[];
+};
+export declare type QueryParams = SearchQueryOptions & {
+    env: string;
+    internalPageIndex: number;
+    internalPaging: boolean;
+    linkDepth: number;
+    loadMorePaging: boolean;
+    pagesLoaded: number[];
+    prevPageIndex: number;
+    projectId: string;
+    selectedFilters: {
+        [key: string]: string;
+    };
+};
+export declare type SearchQuery = ({ contentTypeIds, customWhere, dynamicOrderBy, excludeIds, featuredResults, fields, filters, languages, pageSize, pageIndex, orderBy, searchTerm, versionStatus, webpageTemplates, weightedSearchFields, }: SearchQueryOptions, isFeatured?: boolean) => Query;
+export declare type FilterQuery = (contentTypeIds: string[], versionStatus: VersionStatus, customWhere?: CustomWhereClause) => Query;

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

@@ -0,0 +1,180 @@
+import { Context } from './Enums';
+import { AppState } from './SearchState';
+export declare type Tab = {
+    /** The facet to render as default */
+    defaultFacet?: string;
+    /** The zero-based incrementing id assigned to the tab  */
+    id: number;
+    /** The tab's label for rendering  */
+    label: string;
+    /** The facet to render the total results count as default */
+    totalCount?: string;
+};
+export declare type CustomApi = {
+    /** The uri of the REST API implementing a simple GET request */
+    uri: string;
+};
+export declare type Listing = {
+    /** Experimental: use a custom API to retrieve search results */
+    customApi?: CustomApi;
+    /** Experimental: override the rootUrl of the Delivery API client  */
+    env?: string;
+    /** An object with a key for each filter that is required in this facet */
+    filters?: SearchFilters;
+    /** Use this to target the search to a project other than the default configured */
+    projectId?: string;
+    /** Query params object to drive the search for this facet */
+    queryParams: QueryParams;
+    /** Display title */
+    title: string;
+};
+export declare type Facet = {
+    /** The first facet to be shown if no facet is supplied via a route parameter [default false] */
+    isDefault?: boolean;
+    /** Set to true to temporarily disable the facet [default false] */
+    isDisabled?: boolean;
+    /** The id of the tab the facet applies to. Use 0 for default or the id assigned to the tab */
+    tabId?: number;
+} & Listing;
+export declare type SearchFilters = {
+    [key: string]: SearchFilter;
+};
+export declare type SearchFilter = {
+    /** The content type id we will dynamically load entries from and load into state under the items[] */
+    contentTypeId?: string | string[];
+    /** An array of CustomWhereClause to include in the search query when dynamically loading entries via the contentTypeId key */
+    customWhere?: CustomWhereClause;
+    /** The content type field we will apply the filter key to, to filter the list of returned results. */
+    fieldId: string | string[];
+    /** The Delivery API search operator we will use to filter the list of returned results. */
+    fieldOperator?: string;
+    /** The taxonomy path we will dynamically load into state under the items[] */
+    path?: string;
+    /** Setting to true will sync selected filters under matching filter keys in other facets */
+    isGrouped?: boolean;
+    /** Setting to true will ensure only one value can be selected at a time for this filter */
+    isSingleSelect?: boolean;
+    /** Supply an empty array or a hardcoded list of FilterItem depending on the type of filter we require */
+    items: FilterItem[];
+    /** The title to render next to the filter */
+    title: string;
+};
+export declare type FilterItem = {
+    /** Whether the filter is in a selected state */
+    isSelected?: boolean;
+    /** This will usually be the entry id or the taxonomy key */
+    key: string;
+    /** This will usually be the entry slug or the taxonomy path */
+    path?: string;
+    /** The title to render next to the filter item */
+    title: string;
+};
+export declare type FeaturedResults = {
+    /** If the featured results are flagged with a certain field value, specify the fieldId containing the flagged value */
+    fieldId?: string | string[];
+    /** If the featured results are flagged with a certain field value, specify the value in the flagged fieldId */
+    fieldValue?: any;
+    /** If the featured results exist in a special content type provide a contentTypeId */
+    contentTypeId?: string | string[];
+    /** The number of featured results to retrieve */
+    count?: number;
+};
+export declare type QueryParams = {
+    /** An array of assetTypes to search over (sys.dataFormat == 'asset'); Prefix an entry with a "!" to exclude that asset type from the search */
+    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[];
+    /** 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[] */
+    fields?: string[];
+    /** Specify a boolean type field to use for excluding entries we don't want returned in search result  */
+    includeInSearch?: string[];
+    /** Whether or not to load all results with the first page and handle all pagination yourself */
+    internalPaging?: boolean;
+    /** The linkDepth to apply to the facet search (defaults to 0) */
+    linkDepth?: number;
+    /** Alters the pagination style to retain previously loaded pages of results after loading next pages */
+    loadMorePaging?: boolean;
+    /** An array of orderBy expressions to add to the search query */
+    orderBy?: string[];
+    /** The number of items returned per page in the search */
+    pageSize?: number;
+    /** Allow a configured minilist to read the search.term set in state (defaults to false) */
+    useSearchTerm?: boolean;
+    /** 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 */
+    weightedSearchFields?: WeightedSearchField[];
+};
+export declare type WhereClause = {
+    /** The field we wish to query */
+    field: string;
+    /** The value we want to evaluate with the chosen operator */
+    [key: string]: any;
+};
+/**
+ * N.B. This shares syntax with adding where operators to a search query when using the Delivery API via HTTP, and should be used sparingly for exceptional cases where the standard query falls short
+ */
+export declare type CustomWhereClause = (WhereClause | {
+    not: WhereClause;
+} | {
+    and: WhereClause[];
+} | {
+    or: WhereClause[];
+})[];
+export declare type WeightedSearchField = {
+    /** The id of the field to query against */
+    fieldId: string;
+    /** The weighting applied to the field */
+    weight: number;
+};
+/**
+ * To provide all the necessary state information in order to render a fully featured search using Zengenti Isomorphic Base
+ *
+ * You need to provide a search configuration to the reducer so the initialState for your search can be set, this tells the package what you need your search to do, and where to get its data from.
+ */
+export declare type SearchConfig = {
+    /** An object with a key for each facet that is required for the search */
+    facets: {
+        [key: string]: Facet;
+    };
+    /** An object with a key for each independent listing that is required for the site */
+    listings?: {
+        [key: string]: Listing;
+    };
+    /** An object with a key for each independent listing that is required for the site */
+    minilist?: {
+        [key: string]: Listing;
+    };
+    /** An Array of Tabs */
+    tabs: Tab[];
+};
+export declare type ConfigTypes = {
+    [key: string]: Facet;
+} | {
+    [key: string]: Listing;
+};
+export declare type Mappers = {
+    customApi?: (queryParams: QueryParams) => {
+        [key: string]: string;
+    };
+    results: (entries: any[], facet?: string, context?: Context, state?: AppState) => any[];
+    filterItems?: (entries: any[]) => any[];
+    navigate?: ({ state, facet, orderBy, pageIndex, term, }: {
+        state: AppState;
+        facet?: string;
+        orderBy?: string;
+        pageIndex: number;
+        term?: string;
+    }) => NavigateUri;
+    resultsInfo?: (state: AppState) => any;
+};
+export declare type NavigateUri = {
+    path: string;
+    search: string;
+    hash: string;
+};
+export declare type SearchTransformations = Mappers;

package/models/search/models/SearchActions.d.ts

@@ -0,0 +1,127 @@
+import { List } from 'immutable';
+import { PagedList } from 'contensis-core-api';
+import { Entry, TaxonomyNode } from 'contensis-delivery-api/lib/models';
+import { Context } from '../models/Enums';
+import { Facet, Listing, Mappers } from '../models/Search';
+import { AppState } from './SearchState';
+import { QueryParams } from './Queries';
+import { TimedSearchResponse } from './SearchUtil';
+declare type Action = {
+    type: string;
+};
+export declare type WithMappers<T> = T & {
+    mappers: Mappers;
+};
+export declare type DebugFlags = boolean | {
+    executeSearch?: boolean;
+    preloadOtherFacets?: boolean;
+};
+export declare type TriggerSearchParams = {
+    config?: Facet | Listing;
+    context: Context;
+    debug?: DebugFlags;
+    defaultLang?: string;
+    excludeIds?: string[];
+    facet: string;
+    mapper?: Mappers['results'];
+    mappers?: Mappers;
+    params?: {
+        [key: string]: string;
+    };
+};
+export declare type TriggerSearchAction = Action & TriggerSearchParams;
+export declare type TriggerSearchActionCreator = (p: TriggerSearchParams) => TriggerSearchAction;
+declare type InitListingParams = {
+    context: Context;
+    debug?: DebugFlags;
+    defaultLang?: string;
+    facet: string;
+    listingType?: string;
+    mapper?: Mappers['results'];
+    mappers?: Mappers;
+    params: {
+        [key: string]: string;
+    };
+    preload?: boolean;
+};
+export declare type InitListingAction = Action & InitListingParams & {
+    ssr?: boolean;
+};
+export declare type InitListingActionCreator = (p: InitListingParams) => InitListingAction;
+export declare type LoadFiltersSearchResults = Action & {
+    error: any;
+    facetKey: string;
+    filterKey: string;
+    payload: TaxonomyNode | PagedList<Entry>;
+    selectedKeys: List<string>;
+    context: Context;
+    mapper: Mappers['filterItems'];
+};
+export declare type SearchResults = {
+    action: ExecuteSearchAction;
+    featuredResult?: TimedSearchResponse;
+    pageIndex: number;
+    prevResults: List<any>;
+    result: TimedSearchResponse;
+    state: AppState;
+};
+export declare type LoadFiltersCompleteAction = Action & {
+    error: any;
+    facetKey: string;
+    filterKey: string;
+    payload: TaxonomyNode | PagedList<Entry>;
+    selectedKeys: List<string>;
+    context: Context;
+    mapper: Mappers['filterItems'];
+};
+export declare type EnsureSearchAction = InitListingAction & {
+    ogState: AppState;
+};
+export declare type ExecuteSearchAction = EnsureSearchAction & {
+    preload: boolean;
+    queryParams: QueryParams;
+};
+export declare type SetSearchEntriesParams = {
+    type: string;
+    context: Context;
+    defaultLang: string;
+    facet: string;
+    mappers: Mappers;
+    nextFacet: Facet;
+    preload: boolean;
+    ogState: AppState;
+    debug: DebugFlags;
+    params: {
+        [key: string]: string;
+    };
+};
+export declare type SetSearchEntriesAction = Action & SetSearchEntriesParams;
+export declare type ApplySearchFilterAction = Action & {
+    filter: string;
+    key: string;
+};
+export declare type ApplySearchFilterActionCreator = (filter: string, key: string) => ApplySearchFilterAction;
+export declare type ClearFiltersAction = Action;
+export declare type ClearFiltersActionCreator = () => ClearFiltersAction;
+export declare type UpdateCurrentFacetAction = Action & {
+    facet: string;
+};
+export declare type UpdateCurrentFacetActionCreator = (facet: string) => UpdateCurrentFacetAction;
+export declare type UpdateCurrentTabAction = Action & {
+    id: number;
+};
+export declare type UpdateCurrentTabActionCreator = (id: number) => UpdateCurrentFacetAction;
+export declare type UpdateSearchTermAction = Action & {
+    term: string;
+};
+export declare type UpdateSearchTermActionCreator = (term: string) => UpdateSearchTermAction;
+export declare type UpdateSortOrderAction = Action & {
+    orderBy: string;
+    facet: string;
+};
+export declare type UpdateSortOrderActionCreator = (orderBy: string, facet: string) => UpdateSortOrderAction;
+export declare type UpdatePageIndexAction = Action & {
+    pageIndex: number;
+};
+export declare type UpdatePageIndexActionCreator = (pageIndex: number) => UpdatePageIndexAction;
+export {};

package/models/search/models/SearchProps.d.ts

@@ -0,0 +1,45 @@
+import { clearFilters, updateCurrentFacet, updateCurrentTab, updatePageIndex, updateSearchTerm, updateSelectedFilters, updateSortOrder } from '../redux/actions';
+import { Facet, Facets, Filters, Paging } from '../models/SearchState';
+export interface ListingProps<SearchResults = any> {
+    clearFilters: typeof clearFilters;
+    currentListing: string;
+    currentPageIndex: number;
+    featured: SearchResults[];
+    filters: Filters;
+    isLoading: boolean;
+    paging: Paging;
+    pageIsLoading: boolean;
+    results: SearchResults[];
+    resultsInfo: any;
+    searchTerm: string;
+    sortOrder: string[];
+    updateCurrentFacet: typeof updateCurrentFacet;
+    updatePageIndex: typeof updatePageIndex;
+    updateSearchTerm: typeof updateSearchTerm;
+    updateSelectedFilters: typeof updateSelectedFilters;
+    updateSortOrder: typeof updateSortOrder;
+}
+export interface SearchProps<SearchResults = any> {
+    clearFilters: typeof clearFilters;
+    currentFacet: string;
+    currentPageIndex: number;
+    currentTabIndex: number;
+    facet: Facet;
+    facets: Facets;
+    featuredResults: SearchResults[];
+    filters: Filters;
+    isLoading: boolean;
+    paging: Paging;
+    pageIsLoading: boolean;
+    results: SearchResults[];
+    resultsInfo: any;
+    searchTerm: string;
+    sortOrder: string[];
+    tabsAndFacets: any;
+    updateCurrentFacet: typeof updateCurrentFacet;
+    updateCurrentTab: typeof updateCurrentTab;
+    updatePageIndex: typeof updatePageIndex;
+    updateSearchTerm: typeof updateSearchTerm;
+    updateSelectedFilters: typeof updateSelectedFilters;
+    updateSortOrder: typeof updateSortOrder;
+}

package/models/search/models/SearchState.d.ts

@@ -0,0 +1,83 @@
+import { List, Map, OrderedMap } from 'immutable';
+import { initialState, searchFacet } from '../redux/schema';
+import { CustomWhereClause } from './Search';
+export declare type AppState = Map<'search', typeof initialState>;
+export declare type SearchState = {
+    currentFacet: string;
+    term: string;
+    facets: OrderedMap<string, OrderedMap<string, typeof searchFacet>>;
+    tabs: List<Tab>;
+    config: Map<string, boolean>;
+};
+export declare type Facets = {
+    [key: string]: Facet;
+};
+export declare type Facet = {
+    entries: {
+        isLoading: boolean;
+        isError: boolean;
+    };
+    featuredEntries: {
+        isLoading: boolean;
+        isError: boolean;
+    };
+    featuredResults: any[];
+    filters: Filters;
+    pagingInfo: {
+        isLoading: boolean;
+        pageCount: number;
+        pageSize: number;
+        pageIndex: number;
+        totalCount: number;
+    };
+    preloaded: boolean;
+    queryDuration: number;
+    queryParams: {
+        contentTypeIds: string[];
+        dynamicOrderBy: string[];
+    };
+    results: any[];
+    tabId: number;
+    title: string;
+};
+export declare type Filters = {
+    [key: string]: Filter;
+};
+export declare type Filter = {
+    contentTypeId?: string;
+    customWhere?: CustomWhereClause;
+    fieldId?: string;
+    isGrouped?: boolean;
+    isSingleSelect?: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    items?: FilterItem[];
+    path?: string;
+    title?: string;
+};
+export declare type FilterItem = {
+    contentTypeId?: string;
+    title?: string;
+    type?: string;
+    key: string;
+    path?: string;
+    isSelected: boolean;
+};
+export declare type Paging = {
+    isLoading: boolean;
+    pageCount: number;
+    pageIndex: number;
+    pageSize: number;
+    pagesLoaded: number[];
+    prevPageIndex: number;
+    totalCount: number;
+};
+export declare type Tab = {
+    currentFacet: string;
+    facets: {
+        [key: string]: Facet;
+    };
+    id: number;
+    label: string;
+    totalCount: number;
+};

package/models/search/models/SearchUtil.d.ts

@@ -0,0 +1,6 @@
+import { Entry } from 'contensis-delivery-api/lib/models';
+import { PagedList } from 'contensis-core-api';
+export declare type TimedSearchResponse = {
+    duration: number;
+    payload: PagedList<Entry> | any[];
+};

package/models/search/models/index.d.ts

@@ -0,0 +1,3 @@
+export type { CustomApi, CustomWhereClause, Facet as SearchFacet, FeaturedResults, FilterItem, Listing, NavigateUri, QueryParams, SearchConfig, SearchFilter, SearchFilters, SearchTransformations, Tab, WeightedSearchField, } from './Search';
+export type { ListingProps, SearchProps } from './SearchProps';
+export type { Facet, Filter, Filters } from './SearchState';

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

@@ -0,0 +1,39 @@
+import { Mappers } from '../models/Search';
+import { ClearFiltersActionCreator, InitListingActionCreator, TriggerSearchActionCreator } from '../models/SearchActions';
+export declare const withMappers: <T>(action: T, mappers: Mappers) => T & {
+    mappers: Mappers;
+};
+export declare const triggerSearch: TriggerSearchActionCreator;
+export declare const initListing: InitListingActionCreator;
+export declare const navigate: (path: string, state?: any) => {
+    type: string;
+    path: string;
+    state: any;
+};
+export declare const clearFilters: ClearFiltersActionCreator;
+export declare const updatePageIndex: (pageIndex: number) => {
+    type: string;
+    pageIndex: number;
+};
+export declare const updateCurrentFacet: (facet: string) => {
+    type: string;
+    facet: string;
+};
+export declare const updateCurrentTab: (id: number) => {
+    type: string;
+    id: number;
+};
+export declare const updateSearchTerm: (term: string) => {
+    type: string;
+    term: string;
+};
+export declare const updateSelectedFilters: (filter: string, key: string) => {
+    type: string;
+    filter: string;
+    key: string;
+};
+export declare const updateSortOrder: (orderBy: string, facet?: string | undefined) => {
+    type: string;
+    orderBy: string;
+    facet: string | undefined;
+};

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

@@ -0,0 +1,3 @@
+import { FilterQuery, SearchQuery } from '../models/Queries';
+export declare const filterQuery: FilterQuery;
+export declare const searchQuery: SearchQuery;

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

@@ -0,0 +1,4 @@
+import { List, Map, OrderedMap } from 'immutable';
+import { SearchConfig } from '../models/Search';
+declare const _default: (config: SearchConfig) => (state: OrderedMap<string, string | Map<string, boolean> | OrderedMap<string, OrderedMap<string, OrderedMap<string, string | number | List<any> | Map<string, boolean | List<any>> | Map<string, number | boolean | List<any>> | Map<unknown, unknown> | null>>> | List<import("../models/SearchState").Tab>> | undefined, action: any) => any;
+export default _default;

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

@@ -0,0 +1,20 @@
+import { AppState } from '../models/SearchState';
+import { InitListingAction, TriggerSearchAction } from '../models/SearchActions';
+import { Mappers } from '../models/Search';
+import { Context } from '../models/Enums';
+export declare const searchSagas: import("redux-saga/effects").ForkEffect<never>[];
+export declare function setRouteFilters(action: InitListingAction): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<InitListingAction> | import("redux-saga/effects").CallEffect<void>, void, AppState>;
+export declare function doSearch(action: TriggerSearchAction): Generator<import("redux-saga/effects").SelectEffect | import("redux-saga/effects").PutEffect<{
+    type: string;
+    config?: import("../models/Search").Listing | import("../models/Search").Facet | undefined;
+    context: Context;
+    debug?: import("../models/SearchActions").DebugFlags | undefined;
+    defaultLang?: string | undefined;
+    excludeIds?: string[] | undefined;
+    facet: string;
+    mapper?: ((entries: any[], facet?: string | undefined, context?: Context | undefined, state?: AppState | undefined) => any[]) | undefined;
+    mappers?: Mappers | undefined;
+    params?: {
+        [key: string]: string;
+    } | undefined;
+}> | import("redux-saga/effects").PutEffect<InitListingAction> | import("redux-saga/effects").CallEffect<void>, void, AppState>;

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

@@ -0,0 +1,9 @@
+import { List, Map, OrderedMap } from 'immutable';
+import { CustomWhereClause } from '../models/Search';
+export declare const entries: Map<string, boolean | List<any>>;
+export declare const pagingInfo: Map<string, number | boolean | List<any>>;
+export declare const searchFacet: OrderedMap<string, string | number | List<any> | Map<string, boolean | List<any>> | Map<string, number | boolean | List<any>> | Map<unknown, unknown> | null>;
+export declare const searchTab: Map<string, string | number | OrderedMap<unknown, unknown> | undefined>;
+export declare const filtering: Map<string, string | boolean | List<CustomWhereClause> | List<Map<string, string | boolean>>>;
+export declare const filterItem: Map<string, string | boolean>;
+export declare const initialState: OrderedMap<string, string | Map<string, boolean> | OrderedMap<string, OrderedMap<string, OrderedMap<string, string | number | List<any> | Map<string, boolean | List<any>> | Map<string, number | boolean | List<any>> | Map<unknown, unknown> | null>>> | List<import("../models/SearchState").Tab>>;