@sqrzro/admin 1.0.0-beta.7 → 2.0.0

package/dist/{types/scenes → scenes}/Error404Scene.d.ts

@@ -1,3 +1,3 @@
-import React from 'react';
-declare const Error404Scene: React.FunctionComponent;
-export default Error404Scene;
+import React from 'react';
+declare function Error404Scene(): React.ReactElement;
+export default Error404Scene;

package/dist/scenes/Error404Scene.js

@@ -0,0 +1,5 @@
+import React from 'react';
+function Error404Scene() {
+    return React.createElement("div", null, "Error404Scene");
+}
+export default Error404Scene;

package/dist/services/AppService.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from '../services/ConfigService';
+declare const AppService: {
+    register: (userConfig: Config) => void;
+};
+export default AppService;

package/dist/services/AppService.js

@@ -0,0 +1,11 @@
+import { ApiService } from '@sqrzro/utility';
+import ConfigService from '../services/ConfigService';
+const register = (userConfig) => {
+    const config = ConfigService.registerConfig(userConfig);
+    ApiService.registerConfig({ path: config.paths.api });
+};
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AppService = {
+    register,
+};
+export default AppService;

package/dist/services/ConfigService.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="react" />
+import type { AuthObject } from '@sqrzro/hooks';
+import type { NavigationObject } from '../utility/interfaces';
+export interface Me {
+    name: string;
+    permissions?: string[];
+}
+export declare enum AppLayout {
+    sidebar = "sidebar",
+    topbar = "topbar"
+}
+export interface AppConfigObject {
+    auth: AuthObject;
+    Logo?: React.ComponentType;
+    me?: Me;
+    name: string;
+    navigation: NavigationObject[];
+    paths: {
+        api: string;
+    };
+    style: {
+        brand?: string;
+        isDarkMode?: boolean;
+        layout: AppLayout;
+    };
+}
+export interface Config {
+    auth?: Partial<AppConfigObject['auth']>;
+    Logo?: AppConfigObject['Logo'];
+    me?: AppConfigObject['me'];
+    name?: string;
+    navigation?: AppConfigObject['navigation'];
+    paths?: Partial<AppConfigObject['paths']>;
+    style?: Partial<AppConfigObject['style']>;
+}
+export declare function registerConfig(userConfig: Config): AppConfigObject;
+declare function get(): AppConfigObject;
+declare const ConfigService: {
+    get: typeof get;
+    registerConfig: typeof registerConfig;
+};
+export default ConfigService;

package/dist/services/ConfigService.js

@@ -0,0 +1,52 @@
+import { AuthIdentifier } from '@sqrzro/hooks';
+export var AppLayout;
+(function (AppLayout) {
+    AppLayout["sidebar"] = "sidebar";
+    AppLayout["topbar"] = "topbar";
+})(AppLayout || (AppLayout = {}));
+let appConfig = {
+    auth: {
+        identifier: AuthIdentifier.username,
+        identifierLabel: 'Username',
+        loginUrl: 'tokens',
+        meUrl: 'me',
+        passwordUrl: 'tokens/password',
+        tfa: false,
+    },
+    name: '',
+    navigation: [],
+    paths: { api: 'http://localhost:8081' },
+    style: { isDarkMode: false, layout: AppLayout.sidebar },
+};
+function mergeAppContext(defaults, config) {
+    if (config) {
+        return { ...defaults, ...config };
+    }
+    return defaults;
+}
+export function registerConfig(userConfig) {
+    const config = {
+        auth: mergeAppContext(appConfig.auth, userConfig.auth),
+        name: userConfig.name || 'Square Zero Admin',
+        navigation: userConfig.navigation || appConfig.navigation,
+        paths: userConfig.paths ? { ...appConfig.paths, ...userConfig.paths } : appConfig.paths,
+        style: userConfig.style ? { ...appConfig.style, ...userConfig.style } : appConfig.style,
+    };
+    if (userConfig.Logo) {
+        config.Logo = userConfig.Logo;
+    }
+    if (userConfig.me) {
+        config.me = { ...userConfig.me };
+    }
+    appConfig = config;
+    return appConfig;
+}
+function get() {
+    return appConfig;
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const ConfigService = {
+    get,
+    registerConfig,
+};
+export default ConfigService;

package/dist/{types/services → services}/ConfirmService.d.ts

@@ -1,12 +1,12 @@
-import type { ReactNode } from 'react';
-export interface ConfirmModalData {
-    description: ReactNode;
-    label?: string;
-    onConfirm?: () => void;
-}
-export interface ConfirmObject {
-    ask: (data: ConfirmModalData) => boolean;
-    close: () => boolean;
-}
-declare const ConfirmService: ConfirmObject;
-export default ConfirmService;
+import type { ReactNode } from 'react';
+export interface ConfirmModalData {
+    description: ReactNode;
+    label?: string;
+    onConfirm?: () => void;
+}
+export interface ConfirmObject {
+    ask: (data: ConfirmModalData) => boolean;
+    close: () => boolean;
+}
+declare const ConfirmService: ConfirmObject;
+export default ConfirmService;

package/dist/services/ConfirmService.js

@@ -0,0 +1,10 @@
+import { EventService } from '@sqrzro/utility';
+function ask(data) {
+    return EventService.publish('@confirm/send', data);
+}
+function close() {
+    return EventService.publish('@confirm/send', null);
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const ConfirmService = { ask, close };
+export default ConfirmService;

package/dist/services/DateService.d.ts

@@ -0,0 +1,26 @@
+import type { StrictSimpleObject } from '../utility/interfaces';
+interface DateItem {
+    id: number;
+    name: string | null;
+}
+declare function getDays(): DateItem[];
+declare function getMonths(): DateItem[];
+declare function getYears(startYear?: number, endYear?: number): DateItem[];
+declare function isToday(date: string): boolean;
+declare function getDayOfWeek(date: string): number;
+declare function getDaysInMonth(date: string): number;
+declare function addMonths(date: string, amount: number): string;
+declare function subMonths(date: string, amount: number): string;
+declare function getQuickDates(): StrictSimpleObject[];
+declare const DateService: {
+    addMonths: typeof addMonths;
+    getDaysInMonth: typeof getDaysInMonth;
+    getDayOfWeek: typeof getDayOfWeek;
+    getDays: typeof getDays;
+    getMonths: typeof getMonths;
+    getQuickDates: typeof getQuickDates;
+    getYears: typeof getYears;
+    isToday: typeof isToday;
+    subMonths: typeof subMonths;
+};
+export default DateService;

package/dist/services/DateService.js

@@ -0,0 +1,132 @@
+import { addMonths as fnsAddMonths, getDay as fnsGetDay, getDaysInMonth as fnsGetDaysInMonth, set as fnsSet, subDays as fnsSubDays, subMonths as fnsSubMonths, parseISO, } from 'date-fns';
+import FormatService from './FormatService';
+const DAYS_IN_WEEK = 7;
+const MONTHS_IN_YEAR = 12;
+const DAYS_IN_30_DAYS = 30;
+const DAYS_IN_MONTH = 31;
+const FIRST_YEAR = 1900;
+const SUNDAY = 6;
+function getDays() {
+    return Array(DAYS_IN_MONTH)
+        .fill(0)
+        .map((_item, index) => ({ id: index + 1, name: `${index + 1}` }));
+}
+function getMonths() {
+    return Array(MONTHS_IN_YEAR)
+        .fill(0)
+        .map((_item, index) => ({
+        id: index + 1,
+        name: FormatService.date(new Date(FIRST_YEAR, index, 1), 'MMMM'),
+    }));
+}
+function getYears(startYear = FIRST_YEAR, endYear = new Date().getFullYear()) {
+    return Array(endYear - startYear + 1)
+        .fill(0)
+        .map((_item, index) => ({ id: endYear - index, name: `${endYear - index}` }));
+}
+function isToday(date) {
+    return FormatService.date(new Date(), 'y-MM-dd') === date;
+}
+// Most date libraries start the week on Sunday (US). We want to start on Monday (UK).
+function adjustDayOfWeek(num) {
+    return num === 0 ? SUNDAY : num - 1;
+}
+function getDayOfWeek(date) {
+    const parsed = parseISO(date);
+    const num = adjustDayOfWeek(fnsGetDay(parsed));
+    return Number.isNaN(num) ? -1 : num;
+}
+function getDaysInMonth(date) {
+    const parsed = parseISO(date);
+    const num = fnsGetDaysInMonth(parsed);
+    return Number.isNaN(num) ? -1 : num;
+}
+function addMonths(date, amount) {
+    const parsed = parseISO(`${date}-01`);
+    return FormatService.date(fnsAddMonths(parsed, amount), 'y-MM');
+}
+function subMonths(date, amount) {
+    const parsed = parseISO(`${date}-01`);
+    return FormatService.date(fnsSubMonths(parsed, amount), 'y-MM');
+}
+// Quick Date
+const QUICK_DATE_FORMAT = 'Y-MM-dd';
+function getToday() {
+    return new Date();
+}
+function getYesterday() {
+    return fnsSubDays(new Date(), 1);
+}
+function getLast7Days() {
+    return [fnsSubDays(new Date(), DAYS_IN_WEEK), new Date()];
+}
+function getLast30Days() {
+    return [fnsSubDays(new Date(), DAYS_IN_30_DAYS), new Date()];
+}
+// Get the first day of this month, and today
+function getThisMonth() {
+    return [fnsSet(new Date(), { date: 1 }), getToday()];
+}
+// Get the first day of last month, and the day before the first day of this month
+function getLastMonth() {
+    return [fnsSet(fnsSubMonths(new Date(), 1), { date: 1 }), fnsSubDays(getThisMonth()[0], 1)];
+}
+function getQuickDateId(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => FormatService.date(item, QUICK_DATE_FORMAT)).join(',');
+    }
+    const formatted = FormatService.date(value, QUICK_DATE_FORMAT);
+    return `${formatted},${formatted}`;
+}
+function getQuickDates() {
+    const today = new Date();
+    const dates = [
+        {
+            id: getToday(),
+            name: 'Today',
+        },
+        {
+            id: getYesterday(),
+            name: 'Yesterday',
+        },
+        {
+            id: getLast7Days(),
+            name: 'Last 7 Days',
+        },
+        {
+            id: getLast30Days(),
+            name: 'Last 30 Days',
+        },
+    ];
+    /*
+     * If the date is the 8th or 31st of the month, it matches up with last 7 days or last 30 days,
+     * respectively, and causes duplicate key errors. So best just leave it out in these cases.
+     */
+    if (today.getDate() !== DAYS_IN_WEEK + 1 && today.getDate() !== DAYS_IN_MONTH) {
+        dates.push({
+            id: getThisMonth(),
+            name: 'This Month',
+        });
+    }
+    dates.push({
+        id: getLastMonth(),
+        name: 'Last Month',
+    });
+    return dates.map((item) => ({
+        id: getQuickDateId(item.id),
+        name: item.name,
+    }));
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const DateService = {
+    addMonths,
+    getDaysInMonth,
+    getDayOfWeek,
+    getDays,
+    getMonths,
+    getQuickDates,
+    getYears,
+    isToday,
+    subMonths,
+};
+export default DateService;

package/dist/services/DateService.spec.d.ts

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

package/dist/services/DateService.spec.js

@@ -0,0 +1,83 @@
+import MockDate from 'mockdate';
+import DateService from './DateService';
+describe('DateService', () => {
+    it('should addMonths', () => {
+        expect(DateService.addMonths('2020-01', 4)).toBe('2020-05');
+        expect(DateService.addMonths('1946-07', 12)).toBe('1947-07');
+        expect(DateService.addMonths('2050-02', 1)).toBe('2050-03');
+        expect(DateService.addMonths('2021-02', 0)).toBe('2021-02');
+        expect(DateService.addMonths('lorem', 5)).toBe('');
+    });
+    it('should getDaysInMonth', () => {
+        expect(DateService.getDaysInMonth('2020-01')).toBe(31);
+        expect(DateService.getDaysInMonth('2020-02')).toBe(29);
+        expect(DateService.getDaysInMonth('1950-09')).toBe(30);
+        expect(DateService.getDaysInMonth('lorem')).toBe(-1);
+    });
+    it('should getDayOfWeek', () => {
+        expect(DateService.getDayOfWeek('1987-04-18')).toBe(5);
+        expect(DateService.getDayOfWeek('2018-06-17')).toBe(6);
+        expect(DateService.getDayOfWeek('2028-05-18')).toBe(3);
+        expect(DateService.getDayOfWeek('2045-08-07')).toBe(0);
+        expect(DateService.getDayOfWeek('2046-01-02')).toBe(1);
+        expect(DateService.getDayOfWeek('lorem')).toBe(-1);
+    });
+    it('should getDays', () => {
+        const days = DateService.getDays();
+        expect(days[0]).toEqual({ id: 1, name: '1' });
+        expect(days[17]).toEqual({ id: 18, name: '18' });
+        expect(days[40]).toBeUndefined();
+    });
+    it('should getMonths', () => {
+        const months = DateService.getMonths();
+        expect(months[0]).toEqual({ id: 1, name: 'January' });
+        expect(months[7]).toEqual({ id: 8, name: 'August' });
+        expect(months[14]).toBeUndefined();
+    });
+    it('should getQuickDates', () => {
+        MockDate.set('2000-11-22');
+        const dates = DateService.getQuickDates();
+        expect(dates).toHaveLength(6);
+        expect(dates[0]).toEqual({ id: '2000-11-22,2000-11-22', name: 'Today' });
+        expect(dates[1]).toEqual({ id: '2000-11-21,2000-11-21', name: 'Yesterday' });
+        expect(dates[2]).toEqual({ id: '2000-11-15,2000-11-22', name: 'Last 7 Days' });
+        expect(dates[3]).toEqual({ id: '2000-10-23,2000-11-22', name: 'Last 30 Days' });
+        expect(dates[4]).toEqual({ id: '2000-11-01,2000-11-22', name: 'This Month' });
+        expect(dates[5]).toEqual({ id: '2000-10-01,2000-10-31', name: 'Last Month' });
+    });
+    it('should getQuickDates (8th of month)', () => {
+        MockDate.set('2000-11-08');
+        const dates = DateService.getQuickDates();
+        expect(dates).toHaveLength(5);
+    });
+    it('should getQuickDates (31st of month)', () => {
+        MockDate.set('2000-12-31');
+        const dates = DateService.getQuickDates();
+        expect(dates).toHaveLength(5);
+    });
+    describe('should getYears', () => {
+        it('should get default years', () => {
+            MockDate.set('2021-11-22');
+            const years = DateService.getYears();
+            expect(years[0]).toEqual({ id: 2021, name: '2021' });
+            expect(years[17]).toEqual({ id: 2004, name: '2004' });
+            expect(years[200]).toBeUndefined();
+        });
+        it('should get custom years', () => {
+            expect(DateService.getYears(2000, 2016)[3]).toEqual({ id: 2013, name: '2013' });
+        });
+    });
+    describe('should isToday', () => {
+        MockDate.set('2000-11-22');
+        expect(DateService.isToday('2000-11-22')).toBe(true);
+        expect(DateService.isToday('2001-11-22')).toBe(false);
+        expect(DateService.isToday('lorem')).toBe(false);
+    });
+    describe('should subMonths', () => {
+        expect(DateService.subMonths('2020-01', 4)).toBe('2019-09');
+        expect(DateService.subMonths('1946-07', 12)).toBe('1945-07');
+        expect(DateService.subMonths('2050-02', 1)).toBe('2050-01');
+        expect(DateService.subMonths('2021-02', 0)).toBe('2021-02');
+        expect(DateService.subMonths('lorem', 5)).toBe('');
+    });
+});

package/dist/services/DownloadService.d.ts

@@ -0,0 +1,7 @@
+declare function makeUrl(alias: string): string;
+declare function download(alias: string): void;
+declare const DownloadService: {
+    download: typeof download;
+    makeUrl: typeof makeUrl;
+};
+export default DownloadService;

package/dist/services/DownloadService.js

@@ -0,0 +1,16 @@
+import { ApiService, AuthService, ifWindow } from '@sqrzro/utility';
+import FilterService from '../services/FilterService';
+function makeUrl(alias) {
+    const query = { dl: '1', token: AuthService.getToken() };
+    const filters = FilterService.getFiltersFromContext(null);
+    return ApiService.makeUrl([alias, query, filters]);
+}
+function download(alias) {
+    ifWindow((win) => win.open(makeUrl(alias)));
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const DownloadService = {
+    download,
+    makeUrl,
+};
+export default DownloadService;

package/dist/services/DownloadService.spec.d.ts

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

package/dist/services/DownloadService.spec.js

@@ -0,0 +1,18 @@
+import DownloadService from './DownloadService';
+jest.mock('@/services/AuthService', () => ({
+    getToken: () => 'token',
+}));
+describe('DownloadService', () => {
+    it('should make url', () => {
+        const url = DownloadService.makeUrl('lorem');
+        expect(url).toBe('http://example.com/lorem?dl=1&token=token');
+    });
+    it('should download', () => {
+        jest.spyOn(window, 'open').mockImplementation(() => null);
+        expect(window.open).toHaveBeenCalledTimes(0);
+        DownloadService.download('lorem');
+        expect(window.open).toHaveBeenCalledTimes(1);
+        expect(window.open).toHaveBeenLastCalledWith('http://example.com/lorem?dl=1&token=token');
+        window.open.mockClear();
+    });
+});

package/dist/{types/services → services}/FilterComponentService.d.ts

@@ -1,25 +1,25 @@
-import type { FilterField, FilterOptions } from '../filters/interfaces';
-/**
- * This service returns a number of FilterField objects, each one representing a different type of
- * filter that can be used for lists and tables.
- *
- * The filters are used by creating an array of FilterField objects (using the
- * FilterComponentService to help), and passing it to the `Filters` component (usually through
- * either a `List` or `Table` component, or some variation thereof)
- *
- * An example set of filters would be:
- *
- * ```
- * const filters = [
- *     booleanFilter({ label: 'Active?', name: 'is_active' }),
- *     dateFilter({ label: 'Created', name: 'created_at' }),
- * ];
- * ```
- */
-declare const FilterComponentService: {
-    boolean: (options: FilterOptions) => FilterField;
-    date: (options: FilterOptions) => FilterField;
-    dropdown: (options: FilterOptions) => FilterField;
-    quickDate: (options: FilterOptions) => FilterField;
-};
-export default FilterComponentService;
+import type { FilterField, FilterOptions } from '../filters/interfaces';
+/**
+ * This service returns a number of FilterField objects, each one representing a different type of
+ * filter that can be used for lists and tables.
+ *
+ * The filters are used by creating an array of FilterField objects (using the
+ * FilterComponentService to help), and passing it to the `Filters` component (usually through
+ * either a `List` or `Table` component, or some variation thereof)
+ *
+ * An example set of filters would be:
+ *
+ * ```
+ * const filters = [
+ *     booleanFilter({ label: 'Active?', name: 'is_active' }),
+ *     dateFilter({ label: 'Created', name: 'created_at' }),
+ * ];
+ * ```
+ */
+declare const FilterComponentService: {
+    boolean: (options: FilterOptions) => FilterField;
+    date: (options: FilterOptions) => FilterField;
+    dropdown: (options: FilterOptions) => FilterField;
+    quickDate: (options: FilterOptions) => FilterField;
+};
+export default FilterComponentService;

package/dist/services/FilterComponentService.js

@@ -0,0 +1,54 @@
+/* eslint-disable react/display-name */
+import React from 'react';
+import BooleanFilter, { renderSummary as renderBooleanSummary } from '../filters/BooleanFilter';
+import DateFilter, { renderSummary as renderDateSummary } from '../filters/DateFilter';
+import DropdownFilter, { renderSummary as renderDropdownSummary } from '../filters/DropdownFilter';
+import QuickDateFilter, { renderSummary as renderQuickDateSummary, } from '../filters/QuickDateFilter';
+const booleanFilter = (options) => ({
+    ...options,
+    renderField: (props) => React.createElement(BooleanFilter, { ...props }),
+    renderSummary: renderBooleanSummary,
+});
+const dateFilter = (options) => ({
+    ...options,
+    panelOptions: { size: 'lg' },
+    renderField: (props) => React.createElement(DateFilter, { ...props }),
+    renderSummary: renderDateSummary,
+});
+const dropdownFilter = (options) => ({
+    ...options,
+    panelOptions: { isScrollable: true },
+    renderField: (props) => React.createElement(DropdownFilter, { ...props }),
+    renderSummary: renderDropdownSummary,
+});
+const quickDateFilter = (options) => ({
+    ...options,
+    panelOptions: [{}, { size: 'lg' }],
+    renderField: (props) => React.createElement(QuickDateFilter, { ...props }),
+    renderSummary: renderQuickDateSummary,
+});
+/**
+ * This service returns a number of FilterField objects, each one representing a different type of
+ * filter that can be used for lists and tables.
+ *
+ * The filters are used by creating an array of FilterField objects (using the
+ * FilterComponentService to help), and passing it to the `Filters` component (usually through
+ * either a `List` or `Table` component, or some variation thereof)
+ *
+ * An example set of filters would be:
+ *
+ * ```
+ * const filters = [
+ *     booleanFilter({ label: 'Active?', name: 'is_active' }),
+ *     dateFilter({ label: 'Created', name: 'created_at' }),
+ * ];
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const FilterComponentService = {
+    boolean: booleanFilter,
+    date: dateFilter,
+    dropdown: dropdownFilter,
+    quickDate: quickDateFilter,
+};
+export default FilterComponentService;

package/dist/services/FilterService.d.ts

@@ -0,0 +1,34 @@
+import type { FilterMap } from '../utility/interfaces';
+interface FilterContext {
+    location?: {
+        pathname: string;
+        search: string;
+    };
+    path?: string;
+    query?: {
+        filter?: Record<string, string[] | string>;
+    };
+}
+/**
+ * Take either a query string (from a window.location.search, for example) or a query object (e.g.
+ * from an Express-style Request object), and return a filter map.
+ *
+ * @param ctx Either a window element or an Express-style Request object
+ * @returns A filter map for the specified filters
+ */
+declare function getFiltersFromContext(ctx: FilterContext | null): FilterMap;
+/**
+ * Take either a query string (from a window.location.search, for example) or a query object (e.g.
+ * from an Express-style Request object), and a filter map of the specified filter values, and
+ * return a url that can be used to apply those specified filters.
+ *
+ * @param ctx Either a window element or an Express-style Request object
+ * @param filters A filter map for the specified filters
+ * @returns A url with the specified filters applied
+ */
+declare function setFiltersUrlFromContext(ctx: FilterContext | null, filters: FilterMap): string;
+declare const FilterService: {
+    getFiltersFromContext: typeof getFiltersFromContext;
+    setFiltersUrlFromContext: typeof setFiltersUrlFromContext;
+};
+export default FilterService;

package/dist/services/FilterService.js

@@ -0,0 +1,58 @@
+import { UrlService, ifWindow, parseSearch } from '@sqrzro/utility';
+function getDefaultContext(context) {
+    if (context) {
+        return context;
+    }
+    return ifWindow((win) => win, null);
+}
+/**
+ * Take either a query string (from a window.location.search, for example) or a query object (e.g.
+ * from an Express-style Request object), and return a filter map.
+ *
+ * @param ctx Either a window element or an Express-style Request object
+ * @returns A filter map for the specified filters
+ */
+function getFiltersFromContext(ctx) {
+    const map = new Map();
+    const context = getDefaultContext(ctx);
+    if (!context) {
+        return map;
+    }
+    const search = context.location ? parseSearch(context.location.search) : context.query;
+    if (!search?.filter || typeof search.filter !== 'object') {
+        return map;
+    }
+    for (const [key, value] of Object.entries(search.filter)) {
+        if (value) {
+            const stringValue = Array.isArray(value)
+                ? value.map((item) => String(item))
+                : value.toString();
+            map.set(key, stringValue);
+        }
+    }
+    return map;
+}
+/**
+ * Take either a query string (from a window.location.search, for example) or a query object (e.g.
+ * from an Express-style Request object), and a filter map of the specified filter values, and
+ * return a url that can be used to apply those specified filters.
+ *
+ * @param ctx Either a window element or an Express-style Request object
+ * @param filters A filter map for the specified filters
+ * @returns A url with the specified filters applied
+ */
+function setFiltersUrlFromContext(ctx, filters) {
+    const context = getDefaultContext(ctx);
+    if (!context) {
+        return '';
+    }
+    const pathname = context.location ? context.location.pathname : context.path;
+    const search = context.location ? parseSearch(context.location.search) : context.query;
+    return UrlService.build(pathname || '', search, filters);
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const FilterService = {
+    getFiltersFromContext,
+    setFiltersUrlFromContext,
+};
+export default FilterService;

package/dist/services/FilterService.spec.d.ts

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