@uxland/primary-shell 3.5.2 → 3.5.4

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/selectors.d.ts

@@ -0,0 +1,156 @@
+import { RootState } from '../../infrastructure/state/store';
+import { IActivityHistoryItem, IActivityHistoryItemCollection } from '../domain/model';
+
+export declare const activityHistoryCollectionsSelector: (state: RootState) => Record<string, IActivityHistoryItemCollection>;
+export declare const activityHistoryMappedItems: ((state: {
+    activityHistoryCollections: {
+        busy: import('../..').IBusyHistoryItem[];
+        error: import('../..').IErrorHistoryItem[];
+        collections: Record<string, IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('../filter/model').IActivityHistoryFilterGroup[];
+    };
+}) => IActivityHistoryItem[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IActivityHistoryItem[];
+    dependencies: [(state: RootState) => Record<string, IActivityHistoryItemCollection>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};
+export declare const activityHistoryGroupedItems: ((state: {
+    activityHistoryCollections: {
+        busy: import('../..').IBusyHistoryItem[];
+        error: import('../..').IErrorHistoryItem[];
+        collections: Record<string, IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
+        searchString: string;
+        filters: import('../filter/model').IActivityHistoryFilterGroup[];
+    };
+}) => import('../..').IActivityHistoryGroup[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IActivityHistoryItem[], resultFuncArgs_1: string, resultFuncArgs_2: import('../domain/specs/spec').ISpec<IActivityHistoryItem>) => import('../..').IActivityHistoryGroup[];
+    memoizedResultFunc: ((resultFuncArgs_0: IActivityHistoryItem[], resultFuncArgs_1: string, resultFuncArgs_2: import('../domain/specs/spec').ISpec<IActivityHistoryItem>) => import('../..').IActivityHistoryGroup[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import('../..').IActivityHistoryGroup[];
+    dependencies: [((state: {
+        activityHistoryCollections: {
+            busy: import('../..').IBusyHistoryItem[];
+            error: import('../..').IErrorHistoryItem[];
+            collections: Record<string, IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('../filter/model').IActivityHistoryFilterGroup[];
+        };
+    }) => IActivityHistoryItem[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[];
+        memoizedResultFunc: ((resultFuncArgs_0: Record<string, IActivityHistoryItemCollection>) => IActivityHistoryItem[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IActivityHistoryItem[];
+        dependencies: [(state: RootState) => Record<string, IActivityHistoryItemCollection>];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }, (state: RootState) => string, ((state: {
+        activityHistoryCollections: {
+            busy: import('../..').IBusyHistoryItem[];
+            error: import('../..').IErrorHistoryItem[];
+            collections: Record<string, IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
+            searchString: string;
+            filters: import('../filter/model').IActivityHistoryFilterGroup[];
+        };
+    }) => import('../domain/specs/spec').ISpec<IActivityHistoryItem>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import('../filter/model').IActivityHistoryFilter[] | undefined) => import('../domain/specs/spec').ISpec<IActivityHistoryItem>;
+        memoizedResultFunc: ((resultFuncArgs_0: import('../filter/model').IActivityHistoryFilter[] | undefined) => import('../domain/specs/spec').ISpec<IActivityHistoryItem>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import('../domain/specs/spec').ISpec<IActivityHistoryItem>;
+        dependencies: [((state: {
+            activityHistoryCollections: {
+                busy: import('../..').IBusyHistoryItem[];
+                error: import('../..').IErrorHistoryItem[];
+                collections: Record<string, IActivityHistoryItemCollection>;
+            };
+            activityHistoryFilters: {
+                searchString: string;
+                filters: import('../filter/model').IActivityHistoryFilterGroup[];
+            };
+        }) => import('../filter/model').IActivityHistoryFilter[] | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import('../filter/model').IActivityHistoryFilterGroup[]) => import('../filter/model').IActivityHistoryFilter[] | undefined;
+            memoizedResultFunc: ((resultFuncArgs_0: import('../filter/model').IActivityHistoryFilterGroup[]) => import('../filter/model').IActivityHistoryFilter[] | undefined) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import('../filter/model').IActivityHistoryFilter[] | undefined;
+            dependencies: [(state: RootState) => import('../filter/model').IActivityHistoryFilterGroup[]];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+            memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+        memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+    memoize: typeof import('@reduxjs/toolkit').weakMapMemoize;
+};

package/dist/primary/shell/src/internal-plugins/activity-history/{domain → activity-history-item/list}/sort-history-items-by-date/sort-history-items-by-date.d.ts

@@ -1,3 +1,3 @@
-import { IActivityHistoryGroup } from '../model';
+import { IActivityHistoryGroup } from '../../domain/model';
 
 export declare const sortGroupsByMostRecentDate: (arr: IActivityHistoryGroup[]) => IActivityHistoryGroup[];

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/sort-history-items-by-date/sort-history-items-by-date.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/remove/reducer.d.ts

@@ -0,0 +1 @@
+export declare function removeActivityHistoryItemReducer(state: any, action: any): void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/search/actions.d.ts

@@ -0,0 +1 @@
+export declare const setSearchString: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "activity-history-filters/setSearchString">;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-bar/activity-history-search-bar.d.ts

@@ -0,0 +1,8 @@
+import { LitElement } from 'lit';
+
+export declare class ActivityHistorySearchBar extends LitElement {
+    render(): import('lit').TemplateResult<1>;
+    static styles: import('lit').CSSResult;
+    searchQuery: string;
+    _handleSearchChange(event: any): void;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-bar/template.d.ts

@@ -0,0 +1,3 @@
+import { ActivityHistorySearchBar } from './activity-history-search-bar';
+
+export declare const template: (props: ActivityHistorySearchBar) => import('lit').TemplateResult<1>;

package/dist/primary/shell/src/internal-plugins/activity-history/{components/activity-history/activity-history-search-header/activity-history-search-header.d.ts → activity-history-item/search/activity-history-search-results/activity-history-search-results.d.ts}

@@ -1,6 +1,6 @@
 import { LitElement } from 'lit';
 
-export declare class ActivityHistorySearchHeader extends LitElement {
+export declare class ActivityHistorySearchResults extends LitElement {
     render(): import('lit').TemplateResult<1>;
     static styles: import('lit').CSSResult;
     searchQuery: string;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-results/template.d.ts

@@ -0,0 +1,3 @@
+import { ActivityHistorySearchResults } from './activity-history-search-results';
+
+export declare const template: (props: ActivityHistorySearchResults) => import('lit').TemplateResult<1>;

package/dist/primary/shell/src/internal-plugins/activity-history/{features/search-items → activity-history-item/search}/bootstrapper.d.ts

@@ -1,4 +1,4 @@
 import { BrokerExtensions } from '@primaria/plugins-core';
 
 export declare const bootstrapSearchItems: (broker: BrokerExtensions) => void;
-export declare const teardownSearchItems: (broker: BrokerExtensions) => void;
+export declare const teardownSearchItems: () => void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/search/handler.d.ts

@@ -0,0 +1,6 @@
+import { BaseHandler } from '../../infrastructure/base-handlers';
+import { SearchActivityHistoryItems } from './request';
+
+export declare class SearchItemsHandler extends BaseHandler {
+    handle(request: SearchActivityHistoryItems): Promise<void>;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/search/reducer.d.ts

@@ -0,0 +1,3 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+
+export declare function setSearchStringReducer(state: any, action: PayloadAction<string>): void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/search/selectors.d.ts

@@ -0,0 +1,3 @@
+import { RootState } from '../../infrastructure/state/store';
+
+export declare const activityHistorySearchStringSelector: (state: RootState) => string;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/slice.d.ts

@@ -0,0 +1,26 @@
+import { addActivityHistoryItemReducer } from './add/add-history-item/reducer';
+import { addActivityHistoryItemsReducer } from './add/add-history-items/reducer';
+import { IActivityHistoryItemCollection, IBusyHistoryItem, IErrorHistoryItem } from './domain/model';
+import { addBusyHistoryItemReducer, removeBusyHistoryItemReducer } from './list/handle-busy/reducers';
+import { addErrorHistoryItemReducer, removeErrorHistoryItemReducer } from './list/handle-error/reducers';
+import { removeActivityHistoryItemReducer } from './remove/reducer';
+import { updateActivityHistoryItemReducer } from './update/reducer';
+
+export declare const activityHistoryCollectionsSlice: import('@reduxjs/toolkit').Slice<{
+    busy: IBusyHistoryItem[];
+    error: IErrorHistoryItem[];
+    collections: Record<string, IActivityHistoryItemCollection>;
+}, {
+    addBusyHistoryItem: typeof addBusyHistoryItemReducer;
+    removeBusyHistoryItem: typeof removeBusyHistoryItemReducer;
+    addActivityHistoryItem: typeof addActivityHistoryItemReducer;
+    updateActivityHistoryItem: typeof updateActivityHistoryItemReducer;
+    addActivityHistoryItems: typeof addActivityHistoryItemsReducer;
+    addErrorHistoryItem: typeof addErrorHistoryItemReducer;
+    removeErrorHistoryItem: typeof removeErrorHistoryItemReducer;
+    removeActivityHistoryItem: typeof removeActivityHistoryItemReducer;
+}, "activity-history-collections", "activity-history-collections", import('@reduxjs/toolkit').SliceSelectors<{
+    busy: IBusyHistoryItem[];
+    error: IErrorHistoryItem[];
+    collections: Record<string, IActivityHistoryItemCollection>;
+}>>;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/update/action.d.ts

@@ -0,0 +1,4 @@
+export declare const updateActivityHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    id: string;
+    item: import('../..').IActivityHistoryItem;
+}, "activity-history-collections/updateActivityHistoryItem">;

package/dist/primary/shell/src/internal-plugins/activity-history/{features/update-history-item → activity-history-item/update}/bootstrapper.d.ts

@@ -1,4 +1,4 @@
 import { BrokerExtensions } from '@primaria/plugins-core';
 
 export declare const bootstrapUpdateHistoryItem: (broker: BrokerExtensions) => void;
-export declare const teardownUpdateHistoryItem: (broker: BrokerExtensions) => void;
+export declare const teardownUpdateHistoryItem: () => void;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/update/handler.d.ts

@@ -0,0 +1,6 @@
+import { StoreBaseHandler } from '../../infrastructure/base-handlers';
+import { UpdateHistoryItemPayload } from './request';
+
+export declare class UpdateHistoryItemHandler extends StoreBaseHandler {
+    handle(payload: UpdateHistoryItemPayload): Promise<void>;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/update/reducer.d.ts

@@ -0,0 +1,7 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IActivityHistoryItem } from '../domain/model';
+
+export declare function updateActivityHistoryItemReducer(state: any, action: PayloadAction<{
+    id: string;
+    item: IActivityHistoryItem;
+}>): void;

package/dist/primary/shell/src/internal-plugins/activity-history/{features/update-history-item → activity-history-item/update}/request.d.ts

@@ -1,4 +1,4 @@
-import { IActivityHistoryItem } from '../../domain/model';
+import { IActivityHistoryItem } from '../domain/model';
 
 export interface UpdateHistoryItemPayload {
     entityId: string;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/update/update-item-in-collection.d.ts

@@ -0,0 +1,3 @@
+import { IActivityHistoryItem } from '../domain/model';
+
+export declare const updateItemInCollection: (collections: Record<string, any>, id: string, updatedItem: IActivityHistoryItem) => Record<string, any>;

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/update/update-item-in-collection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/internal-plugins/activity-history/index.d.ts

@@ -1 +1 @@
-export * from './domain/model';
+export * from './activity-history-item/domain/model';

package/dist/primary/shell/src/internal-plugins/activity-history/infrastructure/base-handlers.d.ts

@@ -0,0 +1,16 @@
+import { Store } from '@reduxjs/toolkit';
+import { PrimariaApi } from '../../..';
+
+export declare class StoreBaseHandler {
+    protected readonly store: Store;
+    constructor(store: Store);
+}
+export declare class ApiBaseHandler {
+    protected readonly api: PrimariaApi;
+    constructor(api: PrimariaApi);
+}
+export declare class BaseHandler {
+    protected readonly store: Store;
+    protected readonly api: PrimariaApi;
+    constructor(store: Store, api: PrimariaApi);
+}

package/dist/primary/shell/src/internal-plugins/activity-history/infrastructure/ioc/container.d.ts

@@ -1,5 +1,7 @@
 import { Container } from 'inversify';
+import { PrimariaApi } from '../../../../api/api';
 
 declare const container: Container;
 declare const lazyInject: (serviceIdentifier: string | symbol | import("inversify").interfaces.Newable<any> | import("inversify").interfaces.Abstract<any>) => (proto: any, key: string) => void;
 export { container, lazyInject };
+export declare const bindDeps: (api: PrimariaApi) => void;

package/dist/primary/shell/src/internal-plugins/activity-history/infrastructure/state/store.d.ts

@@ -1,35 +1,47 @@
 export type RootState = ReturnType<typeof store.getState>;
 export type AppDispatch = typeof store.dispatch;
 export declare const store: import('@reduxjs/toolkit').EnhancedStore<{
-    activityHistory: {
+    activityHistoryCollections: {
         busy: import('../..').IBusyHistoryItem[];
         error: import('../..').IErrorHistoryItem[];
         collections: Record<string, import('../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
         searchString: string;
+        filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
     };
 }, import('@reduxjs/toolkit').UnknownAction, import('@reduxjs/toolkit').Tuple<[import('@reduxjs/toolkit').StoreEnhancer<{
     dispatch: import('@reduxjs/toolkit').ThunkDispatch<{
-        activityHistory: {
+        activityHistoryCollections: {
             busy: import('../..').IBusyHistoryItem[];
             error: import('../..').IErrorHistoryItem[];
             collections: Record<string, import('../..').IActivityHistoryItemCollection>;
+        };
+        activityHistoryFilters: {
             searchString: string;
+            filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
         };
     }, undefined, import('@reduxjs/toolkit').UnknownAction>;
 }>, import('@reduxjs/toolkit').StoreEnhancer]>>;
 export declare const dispatch: import('@reduxjs/toolkit').ThunkDispatch<{
-    activityHistory: {
+    activityHistoryCollections: {
         busy: import('../..').IBusyHistoryItem[];
         error: import('../..').IErrorHistoryItem[];
         collections: Record<string, import('../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
         searchString: string;
+        filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
     };
 }, undefined, import('@reduxjs/toolkit').UnknownAction> & import('@reduxjs/toolkit').Dispatch<import('@reduxjs/toolkit').UnknownAction>;
 export declare const getState: () => {
-    activityHistory: {
+    activityHistoryCollections: {
         busy: import('../..').IBusyHistoryItem[];
         error: import('../..').IErrorHistoryItem[];
         collections: Record<string, import('../..').IActivityHistoryItemCollection>;
+    };
+    activityHistoryFilters: {
         searchString: string;
+        filters: import('../../activity-history-item/filter/model').IActivityHistoryFilterGroup[];
     };
 };