@opengeoweb/layer-select 19.0.0 → 19.1.1

package/dist/src/lib/store/selectors.d.ts

@@ -0,0 +1,200 @@
+import type { TypedUseSelectorHook } from 'react-redux';
+import type { LayerSelectStoreType, ActiveServiceObjectEntities, ServicePopupObject, LayerSelectModuleState, RootState, Filter, LayerWithServiceName } from './types';
+export declare const useAppSelector: TypedUseSelectorHook<RootState>;
+/**
+ * Returns search filter string
+ *
+ * Example getSearchFilter(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: string
+ */
+export declare const getSearchFilter: ((state: LayerSelectModuleState) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LayerSelectStoreType) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: LayerSelectStoreType) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: LayerSelectModuleState) => LayerSelectStoreType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Returns active services array
+ *
+ * Example getActiveServices(store);
+ * @param {object} store store: object - store object
+ * @returns {ActiveServiceObjectEntities} returnType: ActiveServiceObjectEntitiesobject of active services
+ */
+export declare const getActiveServices: (store: LayerSelectModuleState) => ActiveServiceObjectEntities;
+export declare const getActiveServicesDictionary: (state: LayerSelectModuleState) => Record<string, import("./types").ActiveServiceObject>, getActiveServiceById: (state: LayerSelectModuleState, id: string) => {
+    serviceId?: string | undefined;
+    serviceName?: string | undefined;
+    serviceUrl?: string | undefined;
+    abstract?: string | undefined;
+    enabled?: boolean | undefined;
+    filterIds?: string[] | undefined;
+    scope?: import("@opengeoweb/shared").SystemScope | undefined;
+    isLoading?: boolean | undefined;
+    keywords?: string[] | undefined;
+    groups?: string[] | undefined;
+    isInSearch?: boolean | undefined;
+    type?: import("@opengeoweb/shared").ServiceInterface | undefined;
+}, getAllActiveServices: (state: LayerSelectModuleState) => import("./types").ActiveServiceObject[];
+/**
+ * Returns all ids of enabled services
+ *
+ * Example getEnabledServiceIds(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: array of service ids that are enabled
+ */
+export declare const getEnabledServiceIds: ((state: LayerSelectModuleState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./types").ActiveServiceObject[]) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: import("./types").ActiveServiceObject[]) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(state: LayerSelectModuleState) => import("./types").ActiveServiceObject[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Returns ids of all keywords
+ *
+ * Example getAllKeywordIds(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: array of all keyword ids
+ */
+export declare const getAllFilterIds: (store: LayerSelectModuleState) => string[];
+export declare const getAllFilters: (state: LayerSelectModuleState) => Filter[], getAllFilterIdsEntity: (state: LayerSelectModuleState) => string[], getFilterById: (state: LayerSelectModuleState, id: string) => {
+    id: string;
+    name: string;
+    checked?: boolean | undefined;
+    amountVisible?: number | undefined;
+    type: import("./types").FilterType;
+};
+/**
+ * Returns all ids of checked keywords
+ *
+ * Example getCheckedKeywordIds(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: array of keyword ids that are checked
+ */
+export declare const getCheckedFilterIds: ((state: LayerSelectModuleState) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Filter[]) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: Filter[]) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(state: LayerSelectModuleState) => Filter[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export interface FiltersGrouped {
+    groups: Filter[];
+    keywords: Filter[];
+}
+export declare const getFilters: ((state: LayerSelectModuleState) => FiltersGrouped) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./types").ActiveServiceObject[], resultFuncArgs_1: Filter[]) => FiltersGrouped;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./types").ActiveServiceObject[], resultFuncArgs_1: Filter[]) => FiltersGrouped) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => FiltersGrouped;
+    dependencies: [(state: LayerSelectModuleState) => import("./types").ActiveServiceObject[], (state: LayerSelectModuleState) => Filter[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Returns if all keywords are checked
+ *
+ * Example isAllKeywordsChecked(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: boolean if all keywords are checked
+ */
+export declare const isAllFiltersChecked: ((state: LayerSelectModuleState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: LayerSelectStoreType) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: LayerSelectStoreType) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: LayerSelectModuleState) => LayerSelectStoreType];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Returns a filtered active layer object based on the given filter settings
+ * Example: layerSelectSelectors.getFilteredLayers(store, filteredSettings);
+ * @param {object} store store: object - object from which the service state will be extracted
+ * @returns {array} returnType: LayerWithServiceName - an array of all filtered activelayers
+ */
+export declare const getFilteredLayers: (store: RootState) => LayerWithServiceName[];
+/**
+ * Returns service popup details
+ *
+ * Example getServicePopupDetails(store, 'server-id');
+ * @param {object} store store: object - store object
+ * @returns {object} returnType: object of active service
+ */
+export declare const getServicePopupDetails: (store: LayerSelectModuleState) => ServicePopupObject;
+/**
+ * Returns service with active filtered layers from seaerch
+ *
+ * Example getFilteredActiveServices(store);
+ * @param {object} store store: object - store object
+ * @returns {object} returnType: object of active service
+ */
+export declare const getFilteredActiveServices: (store: RootState) => ActiveServiceObjectEntities;

package/dist/src/lib/store/store.d.ts

@@ -0,0 +1,6 @@
+import type { Middleware, Store } from '@reduxjs/toolkit';
+import type { ReducerMap, WebMapStateModuleState, UIModuleState } from '@opengeoweb/store';
+import type { LayerSelectModuleState } from './types';
+export declare const layerSelectReducersMap: ReducerMap;
+export declare const layerSelectMiddlewares: Middleware[];
+export declare const createMockStore: (mockState?: WebMapStateModuleState | LayerSelectModuleState | UIModuleState) => Store;

package/dist/src/lib/store/testData.d.ts

@@ -0,0 +1,17 @@
+export declare const savedStacService: {
+    id: string;
+    name: string;
+    scope: "user";
+    serviceUrl: string;
+    abstract: string;
+    type: "STAC";
+    layers: never[];
+};
+export declare const savedStacServiceInLocalStorage: {
+    [x: string]: {
+        name: string;
+        url: string;
+        abstract: string;
+        type: "STAC";
+    };
+};

package/dist/src/lib/store/types.d.ts

@@ -0,0 +1,72 @@
+import type { EntityState } from '@reduxjs/toolkit';
+import type { ServiceInterface, SystemScope } from '@opengeoweb/shared';
+import type { CoreAppStore, serviceTypes } from '@opengeoweb/store';
+export type RootState = CoreAppStore & LayerSelectModuleState;
+export interface LayerWithServiceName extends serviceTypes.ServiceLayer {
+    serviceName: string;
+}
+export interface ActiveServiceObject {
+    serviceId?: string;
+    serviceName?: string;
+    serviceUrl?: string;
+    abstract?: string;
+    enabled?: boolean;
+    filterIds?: string[];
+    scope?: SystemScope;
+    isLoading?: boolean;
+    keywords?: string[];
+    groups?: string[];
+    isInSearch?: boolean;
+    type?: ServiceInterface;
+}
+export type FilterType = 'keywords' | 'groups';
+export interface Filter {
+    id: string;
+    name: string;
+    checked?: boolean;
+    amountVisible?: number;
+    type: FilterType;
+}
+export type ActiveServiceObjectEntities = Record<string, ActiveServiceObject>;
+export type Filters = EntityState<Filter, string>;
+export type ActiveServiceType = EntityState<ActiveServiceObject, string>;
+export interface FiltersType {
+    searchFilter: string;
+    activeServices: ActiveServiceType;
+    filters: Filters;
+}
+export type PopupVariant = 'edit' | 'add' | 'save' | 'show';
+export interface ServicePopupObject {
+    isOpen: boolean;
+    variant: PopupVariant;
+    url?: string;
+    serviceId?: string;
+}
+export interface LayerSelectStoreType {
+    filters: FiltersType;
+    allServicesEnabled: boolean;
+    servicePopup: ServicePopupObject;
+}
+export interface LayerSelectModuleState {
+    layerSelect?: LayerSelectStoreType;
+}
+export interface SetSearchFilterPayload {
+    filterText: string;
+}
+export interface SetAllServicesEnabledPayload {
+    allServicesEnabled: boolean;
+}
+export interface ToggleServicePopupPayload {
+    url?: string;
+    variant: PopupVariant;
+    serviceId?: string;
+    isOpen: boolean;
+}
+export interface LayerSelectRemoveServicePayload {
+    serviceId: string;
+    serviceUrl?: string;
+}
+export interface ToggleKeywordsPayload {
+    filterId: string;
+    only?: boolean;
+}

package/dist/src/lib/store/utils.d.ts

@@ -0,0 +1,9 @@
+import type { Draft, EntityAdapter } from '@reduxjs/toolkit';
+import type { SystemScope } from '@opengeoweb/shared';
+import type { serviceTypes } from '@opengeoweb/store';
+import type { LayerProps } from '@opengeoweb/webmap';
+import type { Filter, FilterType, LayerSelectStoreType } from './types';
+export declare const getFilterId: (filterType: FilterType, filterName: string) => string;
+export declare const produceFilters: (filterNames: string[], filterType: FilterType, draft: Draft<LayerSelectStoreType>, layerSelectFilterAdapter: EntityAdapter<Filter, string>) => void;
+export declare const filterLayersFromService: (serviceId: string, services: serviceTypes.Services, filterIds: string[], allFiltersActive: boolean, searchString: string) => LayerProps[];
+export declare const isUserAddedService: (scope: SystemScope) => boolean;

package/dist/src/lib/utils/i18n.d.ts

@@ -0,0 +1,7 @@
+import i18n from 'i18next';
+import type { UseTranslationResponse } from 'react-i18next';
+export declare const LAYER_SELECT_NAMESPACE = "layerselect";
+export declare const initLayerSelectI18n: () => typeof i18n;
+export declare const useLayerSelectTranslation: () => UseTranslationResponse<typeof LAYER_SELECT_NAMESPACE, typeof i18n>;
+export declare const translateInTestsAndStories: (key: string, params?: Record<string, string | number> | undefined) => string;
+export { i18n };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/layer-select",
-  "version": "19.0.0",
+  "version": "19.1.1",
   "description": "GeoWeb layer select library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {
@@ -46,6 +46,7 @@
   },
   "files": [
     "dist",
+    "!dist/package.json",
     "README.md",
     "package.json"
   ]