@cccsaurora/howler-ui 2.14.0-dev.269 → 2.14.0-dev.272

package/plugins/HowlerPlugin.d.ts

@@ -0,0 +1,115 @@
+import type { HowlerHelper } from '@cccsaurora/howler-ui/components/elements/display/handlebars/helpers';
+import type { ActionButton } from '@cccsaurora/howler-ui/components/elements/hit/actions/SharedComponents';
+import type { StatusProps } from '@cccsaurora/howler-ui/components/elements/hit/HitBanner';
+import type { PivotLinkProps } from '@cccsaurora/howler-ui/components/elements/hit/related/PivotLink';
+import type { PluginChipProps } from '@cccsaurora/howler-ui/components/elements/PluginChip';
+import type { PluginTypographyProps } from '@cccsaurora/howler-ui/components/elements/PluginTypography';
+import type { CustomActionProps } from '@cccsaurora/howler-ui/components/routes/action/edit/ActionEditor';
+import type { LeadFormProps } from '@cccsaurora/howler-ui/components/routes/dossiers/LeadEditor';
+import type { PivotFormProps } from '@cccsaurora/howler-ui/components/routes/dossiers/PivotForm';
+import type { PluginDocumentation } from '@cccsaurora/howler-ui/components/routes/help/ActionDocumentation';
+import type { i18n as I18N } from 'i18next';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type React from 'react';
+import type { PropsWithChildren } from 'react';
+import type { IPlugin, PluginStore } from 'react-pluggable';
+import type { MainMenuInsertOperation } from './store';
+declare abstract class HowlerPlugin implements IPlugin {
+    abstract name: string;
+    abstract version: string;
+    abstract author: string;
+    abstract description: string;
+    pluginStore: PluginStore;
+    private functionsToRemove;
+    getPluginName(): string;
+    getDependencies(): string[];
+    init(pluginStore: PluginStore): void;
+    activate(): void;
+    deactivate(): void;
+    addLead(format: string, form: (props: LeadFormProps) => React.ReactNode, renderer: (content: string, metadata: any, hit?: Hit) => React.ReactNode): void;
+    addPivot(format: string, form: (props: PivotFormProps) => React.ReactNode, renderer: (props: PivotLinkProps) => React.ReactNode): void;
+    /**
+     * Adds a single menu item to the User Menu group under the Avatar Menu,
+     * items are added before the 'Settings' and 'Logout' menu items.
+     *
+     * @param i18nKey Translation Key or Title
+     * @param route Route to navigate to, '/settings' for example
+     * @param icon JSX Icon element, <Settings/> for example
+     */
+    addUserMenuItem(i18nKey: string, route: string, icon: JSX.Element): void;
+    /**
+     * Adds a single menu item to the Admin Menu group under the Avatar Menu,
+     * items are added to the end of the existing Admin menu items.
+     *
+     * @param i18nKey Translation Key or Title
+     * @param route Route to navigate to, '/settings' for example
+     * @param icon JSX Icon element, <Settings/> for example
+     */
+    addAdminMenuItem(i18nKey: string, route: string, icon: JSX.Element): void;
+    /**
+     * Adds a single route to the system to load, items are added to the end of
+     * base routes defined.
+     *
+     * @param path Route path, should not start with /
+     * @param element Element the route directs to
+     * @param children Child routes if required
+     */
+    addRoute(path: string, element: JSX.Element, children?: []): void;
+    /**
+     * Adds a sitemap entry to the sitemap table, this is used to populate
+     * information on the Breadcrumb component
+     *
+     * @param path The react router path to this route
+     * @param title The title/label to display in breadcrumbs for this route
+     * @param icon The icon component to show beside the title/label
+     * @param isRoot When true, indicates that the breadcrumbs will reset to this one path each time it is encountered
+     * @param isLeaf When true, indicates that this path does not aggregate in breadcrumbs, i.e. will be replaced by next path
+     * @param excluded When true, indicates to breadcrumbs component to not render this route
+     * @param breadcrumbs Static list of breadcrumb paths to be rendered for the given route
+     * @param textWidth The max width of the text when rendering the breadcrumb
+     */
+    addSitemap(path: string, title: string, icon?: JSX.Element, isRoot?: boolean, isLeaf?: boolean, excluded?: boolean, breadcrumbs?: string[], textWidth?: number): void;
+    /**
+     * Adds a route as well as a simple sitemap entry with values derived from the path
+     *
+     * @param path Route path, should not start with /
+     * @param element Element the route directs to
+     * @param children Child routes if required
+     * @param title The title/label to display in breadcrumbs for this route
+     * @param icon The icon component to show beside the title/label
+     */
+    addRouteAndSitemap(path: string, element: JSX.Element, title: string, icon?: JSX.Element, children?: []): void;
+    /**
+     * Adds a new menu item to the Main Menu
+     *
+     * @param operation Insert operation to perform
+     * @param targetId Reference Menu Id
+     * @param id Identifier for new menu entry
+     * @param i18nKey Translation key for new menu entry
+     * @param route Route for new menu entry
+     * @param icon Icon for new menu entry
+     */
+    addMainMenuItem(operation: MainMenuInsertOperation, targetId: string, id: string, i18nKey: string, route: string, icon: JSX.Element): void;
+    /**
+     * Adds a divider to the main menu
+     *
+     * @param operation Insert operation to perform
+     * @param targetId Reference menu id
+     */
+    addMainMenuDivider(operation: MainMenuInsertOperation, targetId: string): void;
+    addOperation(format: string, form: (props: CustomActionProps) => React.ReactNode, documentation: PluginDocumentation): void;
+    on(_event: string, _hit: Hit): any;
+    provider(): React.FC<PropsWithChildren<{}>> | null;
+    setup(): void;
+    localization(_i18n: I18N): void;
+    helpers(): HowlerHelper[];
+    typography(_props: PluginTypographyProps): any;
+    chip(_props: PluginChipProps): any;
+    actions(_hits: Hit[]): ActionButton[];
+    status(_props: StatusProps): React.ReactNode;
+    support(): React.ReactNode;
+    help(): React.ReactNode;
+    settings(_section: 'admin' | 'local' | 'profile' | 'security'): React.ReactNode;
+    integrations(): [string, () => React.ReactNode][];
+}
+export default HowlerPlugin;

package/plugins/HowlerPlugin.js

@@ -0,0 +1,273 @@
+import i18nInstance from '@cccsaurora/howler-ui/i18n';
+import { difference } from 'lodash-es';
+import howlerPluginStore from './store';
+const INTERNAL_FUNCTIONS = [
+    'constructor',
+    'getPluginName',
+    'getDependencies',
+    'init',
+    'activate',
+    'deactivate',
+    'addLead',
+    'addPivot',
+    'addUserMenuItem',
+    'addAdminMenuItem',
+    'addRoute',
+    'addSitemap',
+    'addRouteAndSitemap',
+    'addMainMenuItem',
+    'addMainMenuDivider',
+    'addOperation'
+];
+class HowlerPlugin {
+    pluginStore;
+    functionsToRemove = [];
+    getPluginName() {
+        return `${this.name}@${this.version}`;
+    }
+    getDependencies() {
+        return [];
+    }
+    init(pluginStore) {
+        this.pluginStore = pluginStore;
+    }
+    activate() {
+        difference(Object.getOwnPropertyNames(HowlerPlugin.prototype), INTERNAL_FUNCTIONS).forEach(_function => {
+            this.pluginStore.addFunction(`${this.name}.${_function}`, this[_function]);
+            this.functionsToRemove.push(`${this.name}.${_function}`);
+        });
+        this.localization(i18nInstance);
+    }
+    deactivate() {
+        difference(Object.getOwnPropertyNames(HowlerPlugin.prototype), INTERNAL_FUNCTIONS).forEach(_function => this.pluginStore.removeFunction(`${this.name}.${_function}`));
+        this.functionsToRemove.forEach(name => this.pluginStore.removeFunction(name));
+    }
+    addLead(format, form, renderer) {
+        if (!howlerPluginStore.addLead(format)) {
+            // eslint-disable-next-line no-console
+            console.error(`Lead format ${format} already configured, not enabling for plugin ${this.getPluginName()}`);
+            return;
+        }
+        this.pluginStore.addFunction(`lead.${format}`, renderer);
+        this.functionsToRemove.push(`lead.${format}`);
+        this.pluginStore.addFunction(`lead.${format}.form`, form);
+        this.functionsToRemove.push(`lead.${format}.form`);
+        // eslint-disable-next-line no-console
+        console.debug(`Lead format ${format} enabled for plugin ${this.getPluginName()}`);
+    }
+    addPivot(format, form, renderer) {
+        if (!howlerPluginStore.addPivot(format)) {
+            // eslint-disable-next-line no-console
+            console.error(`Pivot format ${format} already configured, not enabling for plugin ${this.getPluginName()}`);
+            return;
+        }
+        this.pluginStore.addFunction(`pivot.${format}`, renderer);
+        this.functionsToRemove.push(`pivot.${format}`);
+        this.pluginStore.addFunction(`pivot.${format}.form`, form);
+        this.functionsToRemove.push(`pivot.${format}.form`);
+        // eslint-disable-next-line no-console
+        console.debug(`Pivot format ${format} enabled for plugin ${this.getPluginName()}`);
+    }
+    /**
+     * Adds a single menu item to the User Menu group under the Avatar Menu,
+     * items are added before the 'Settings' and 'Logout' menu items.
+     *
+     * @param i18nKey Translation Key or Title
+     * @param route Route to navigate to, '/settings' for example
+     * @param icon JSX Icon element, <Settings/> for example
+     */
+    addUserMenuItem(i18nKey, route, icon) {
+        howlerPluginStore.addUserMenuItem({
+            i18nKey: i18nKey,
+            route: route,
+            icon: icon
+        });
+    }
+    /**
+     * Adds a single menu item to the Admin Menu group under the Avatar Menu,
+     * items are added to the end of the existing Admin menu items.
+     *
+     * @param i18nKey Translation Key or Title
+     * @param route Route to navigate to, '/settings' for example
+     * @param icon JSX Icon element, <Settings/> for example
+     */
+    addAdminMenuItem(i18nKey, route, icon) {
+        howlerPluginStore.addAdminMenuItem({
+            i18nKey: i18nKey,
+            route: route,
+            icon: icon
+        });
+    }
+    /**
+     * Adds a single route to the system to load, items are added to the end of
+     * base routes defined.
+     *
+     * @param path Route path, should not start with /
+     * @param element Element the route directs to
+     * @param children Child routes if required
+     */
+    addRoute(path, element, children) {
+        howlerPluginStore.addRoute({
+            path: path,
+            element: element,
+            children: children
+        });
+    }
+    /**
+     * Adds a sitemap entry to the sitemap table, this is used to populate
+     * information on the Breadcrumb component
+     *
+     * @param path The react router path to this route
+     * @param title The title/label to display in breadcrumbs for this route
+     * @param icon The icon component to show beside the title/label
+     * @param isRoot When true, indicates that the breadcrumbs will reset to this one path each time it is encountered
+     * @param isLeaf When true, indicates that this path does not aggregate in breadcrumbs, i.e. will be replaced by next path
+     * @param excluded When true, indicates to breadcrumbs component to not render this route
+     * @param breadcrumbs Static list of breadcrumb paths to be rendered for the given route
+     * @param textWidth The max width of the text when rendering the breadcrumb
+     */
+    addSitemap(path, title, icon, isRoot, isLeaf, excluded, breadcrumbs, textWidth) {
+        if (isRoot === isLeaf) {
+            throw new Error(`Sitemap '${path}' must define either isRoot or isLeaf as true`);
+        }
+        if (isRoot) {
+            if (breadcrumbs != null) {
+                breadcrumbs = null;
+                console.warn(`Sitemap '${path}' with isRoot should not contain breadcrumbs and have been removed`);
+            }
+        }
+        howlerPluginStore.addSitemap({
+            path: path,
+            title: title,
+            icon: icon,
+            isRoot: isRoot,
+            isLeaf: isLeaf,
+            excluded: excluded,
+            breadcrumbs: breadcrumbs,
+            textWidth: textWidth
+        });
+    }
+    /**
+     * Adds a route as well as a simple sitemap entry with values derived from the path
+     *
+     * @param path Route path, should not start with /
+     * @param element Element the route directs to
+     * @param children Child routes if required
+     * @param title The title/label to display in breadcrumbs for this route
+     * @param icon The icon component to show beside the title/label
+     */
+    addRouteAndSitemap(path, element, title, icon, children) {
+        this.addRoute(path, element, children);
+        const routeParts = path.split('/');
+        let isRoot = true;
+        let isLeaf = false;
+        let breadcrumbs = null;
+        if (routeParts.length > 1) {
+            // Set as leaf and not root
+            isRoot = false;
+            isLeaf = true;
+            // Attempt to auto build breadcrumbs
+            breadcrumbs = [];
+            for (let index = 0; index < routeParts.length - 1; index++) {
+                breadcrumbs.push(`/${routeParts[index]}`);
+            }
+        }
+        this.addSitemap(`/${path}`, title, icon, isRoot, isLeaf, false, breadcrumbs);
+    }
+    /**
+     * Adds a new menu item to the Main Menu
+     *
+     * @param operation Insert operation to perform
+     * @param targetId Reference Menu Id
+     * @param id Identifier for new menu entry
+     * @param i18nKey Translation key for new menu entry
+     * @param route Route for new menu entry
+     * @param icon Icon for new menu entry
+     */
+    addMainMenuItem(operation, targetId, id, i18nKey, route, icon) {
+        if (targetId === '') {
+            targetId = 'root';
+        }
+        howlerPluginStore.addMainMenuItem({
+            operation: operation,
+            targetId: targetId,
+            item: {
+                type: 'item',
+                element: {
+                    id: id,
+                    i18nKey: i18nKey,
+                    route: route,
+                    icon: icon
+                }
+            }
+        });
+    }
+    /**
+     * Adds a divider to the main menu
+     *
+     * @param operation Insert operation to perform
+     * @param targetId Reference menu id
+     */
+    addMainMenuDivider(operation, targetId) {
+        if (targetId === '') {
+            targetId = 'root';
+        }
+        howlerPluginStore.addMainMenuItem({
+            operation: operation,
+            targetId: targetId,
+            item: {
+                type: 'divider',
+                element: null
+            }
+        });
+    }
+    addOperation(format, form, documentation) {
+        if (!howlerPluginStore.addOperation(format)) {
+            // eslint-disable-next-line no-console
+            console.error(`Operation ${format} already configured, not enabling for plugin ${this.getPluginName()}`);
+            return;
+        }
+        this.pluginStore.addFunction(`operation.${format}`, form);
+        this.functionsToRemove.push(`operation.${format}`);
+        this.pluginStore.addFunction(`operation.${format}.documentation`, () => documentation);
+        this.functionsToRemove.push(`operation.${format}.documentation`);
+        // eslint-disable-next-line no-console
+        console.debug(`Operation ${format} enabled for plugin ${this.getPluginName()}`);
+    }
+    on(_event, _hit) {
+        return null;
+    }
+    provider() {
+        return null;
+    }
+    setup() { }
+    localization(_i18n) { }
+    helpers() {
+        return [];
+    }
+    typography(_props) {
+        return null;
+    }
+    chip(_props) {
+        return null;
+    }
+    actions(_hits) {
+        return [];
+    }
+    status(_props) {
+        return null;
+    }
+    support() {
+        return null;
+    }
+    help() {
+        return null;
+    }
+    settings(_section) {
+        return null;
+    }
+    integrations() {
+        return [];
+    }
+}
+export default HowlerPlugin;

package/plugins/store.d.ts

@@ -0,0 +1,95 @@
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import { Event } from 'react-pluggable';
+import type HowlerPlugin from './HowlerPlugin';
+import type { AppLeftNavElement } from '../commons/components/app/AppConfigs';
+export declare class HitEvent extends Event {
+    hit: Hit;
+    constructor(type: string, hit: Hit);
+}
+export declare enum MainMenuInsertOperation {
+    Insert = "INSERT",
+    InsertAfter = "AFTER",
+    InsertBefore = "BEFORE"
+}
+declare class HowlerPluginStore {
+    private _pluginStore;
+    plugins: string[];
+    private _leadFormats;
+    private _pivotFormats;
+    private _operations;
+    private _userMenuItems;
+    private _adminMenuItems;
+    private _mainMenuOperations;
+    private _routes;
+    private _sitemaps;
+    install(plugin: HowlerPlugin): void;
+    addLead(format: string): boolean;
+    addPivot(format: string): boolean;
+    addUserMenuItem(menuItem: {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }): void;
+    addAdminMenuItem(menuItem: {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }): void;
+    addMainMenuItem(menuOperation: {
+        operation: string;
+        targetId: string;
+        item: AppLeftNavElement;
+    }): void;
+    addRoute(route: {
+        path: string;
+        element: JSX.Element;
+        children?: [];
+    }): void;
+    addSitemap(sitemap: {
+        path: string;
+        title: string;
+        icon?: JSX.Element;
+        isRoot?: boolean;
+        isLeaf?: boolean;
+        excluded?: boolean;
+        breadcrumbs?: string[];
+        textWidth?: number;
+    }): void;
+    addOperation(format: string): boolean;
+    get leadFormats(): string[];
+    get pivotFormats(): string[];
+    get operations(): string[];
+    get userMenuItems(): {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }[];
+    get adminMenuItems(): {
+        i18nKey: string;
+        route: string;
+        icon: JSX.Element;
+    }[];
+    get mainMenuOperations(): {
+        operation: string;
+        targetId: string;
+        item: AppLeftNavElement;
+    }[];
+    get routes(): {
+        path: string;
+        element: JSX.Element;
+        children?: [];
+    }[];
+    get sitemaps(): {
+        path: string;
+        title: string;
+        icon?: JSX.Element;
+        isRoot?: boolean;
+        isLeaf?: boolean;
+        excluded?: boolean;
+        breadcrumbs?: string[];
+        textWidth?: number;
+    }[];
+    get pluginStore(): import("react-pluggable").PluginStore;
+}
+declare const howlerPluginStore: HowlerPluginStore;
+export default howlerPluginStore;

package/plugins/store.js

@@ -0,0 +1,96 @@
+import { createPluginStore, Event } from 'react-pluggable';
+export class HitEvent extends Event {
+    hit;
+    constructor(type, hit) {
+        super(type);
+        this.hit = hit;
+    }
+}
+export var MainMenuInsertOperation;
+(function (MainMenuInsertOperation) {
+    MainMenuInsertOperation["Insert"] = "INSERT";
+    MainMenuInsertOperation["InsertAfter"] = "AFTER";
+    MainMenuInsertOperation["InsertBefore"] = "BEFORE";
+})(MainMenuInsertOperation || (MainMenuInsertOperation = {}));
+class HowlerPluginStore {
+    _pluginStore = createPluginStore();
+    plugins = [];
+    _leadFormats = [];
+    _pivotFormats = [];
+    _operations = [];
+    _userMenuItems = [];
+    _adminMenuItems = [];
+    _mainMenuOperations = [];
+    _routes = [];
+    _sitemaps = [];
+    install(plugin) {
+        console.log(`Installing plugin ${plugin.getPluginName()} by ${plugin.author}`);
+        this.plugins.push(plugin.name);
+        this.pluginStore.install(plugin);
+    }
+    addLead(format) {
+        if (this._leadFormats.includes(format)) {
+            return false;
+        }
+        this._leadFormats.push(format);
+        return true;
+    }
+    addPivot(format) {
+        if (this._pivotFormats.includes(format)) {
+            return false;
+        }
+        this._pivotFormats.push(format);
+        return true;
+    }
+    addUserMenuItem(menuItem) {
+        this._userMenuItems.push(menuItem);
+    }
+    addAdminMenuItem(menuItem) {
+        this._adminMenuItems.push(menuItem);
+    }
+    addMainMenuItem(menuOperation) {
+        this._mainMenuOperations.push(menuOperation);
+    }
+    addRoute(route) {
+        this._routes.push(route);
+    }
+    addSitemap(sitemap) {
+        this._sitemaps.push(sitemap);
+    }
+    addOperation(format) {
+        if (this._operations.includes(format)) {
+            return false;
+        }
+        this._operations.push(format);
+        return true;
+    }
+    get leadFormats() {
+        return this._leadFormats;
+    }
+    get pivotFormats() {
+        return this._pivotFormats;
+    }
+    get operations() {
+        return this._operations;
+    }
+    get userMenuItems() {
+        return this._userMenuItems;
+    }
+    get adminMenuItems() {
+        return this._adminMenuItems;
+    }
+    get mainMenuOperations() {
+        return this._mainMenuOperations;
+    }
+    get routes() {
+        return this._routes;
+    }
+    get sitemaps() {
+        return this._sitemaps;
+    }
+    get pluginStore() {
+        return this._pluginStore;
+    }
+}
+const howlerPluginStore = new HowlerPluginStore();
+export default howlerPluginStore;

package/rest/AxiosClient.d.ts

@@ -0,0 +1,10 @@
+import type { HowlerResponse } from '@cccsaurora/howler-ui/api';
+import type RestClient from '@cccsaurora/howler-ui/rest';
+export default class AxiosClient implements RestClient {
+    private cache;
+    private client;
+    constructor();
+    fetch<R>(url: string, method?: 'get' | 'post' | 'put' | 'delete' | 'patch', body?: any, params?: URLSearchParams, headers?: HeadersInit): Promise<[HowlerResponse<R>, number, {
+        [index: string]: any;
+    }]>;
+}

package/rest/AxiosClient.js

@@ -0,0 +1,60 @@
+import axios, { AxiosError } from 'axios';
+import axiosRetry, { exponentialDelay, isNetworkError } from 'axios-retry';
+import { getAxiosCache, setAxiosCache } from '@cccsaurora/howler-ui/utils/sessionStorage';
+class AxiosCache {
+    constructor(_axios) {
+        _axios.interceptors.response.use(async (res) => {
+            const cache = getAxiosCache();
+            if (res.status >= 200 && res.status < 300 && res.headers.etag) {
+                setAxiosCache(res.headers.etag, res.data);
+            }
+            if (res.status === 304) {
+                const etag = res.config.headers['If-Match'];
+                if (etag) {
+                    res.data = cache[etag];
+                }
+            }
+            return res;
+        });
+    }
+}
+export default class AxiosClient {
+    // @ts-ignore
+    cache;
+    client;
+    constructor() {
+        this.client = axios.create({
+            validateStatus: status => (status >= 200 && status < 300) || status === 304
+        });
+        this.cache = new AxiosCache(this.client);
+        axiosRetry(this.client, {
+            retries: 3,
+            retryCondition: err => {
+                return (
+                // Don't retry 502s, as we assume the server handles retries in those cases
+                isNetworkError(err) || (err?.response?.status >= 500 && err?.response?.status !== 502));
+            },
+            retryDelay: exponentialDelay
+        });
+    }
+    async fetch(url, method = 'get', body, params, headers) {
+        const config = {
+            url,
+            params,
+            method,
+            withCredentials: true,
+            data: JSON.stringify(body),
+            headers: headers
+        };
+        try {
+            const response = await this.client(config);
+            return [response.data, response.status, response.headers];
+        }
+        catch (e) {
+            if (e instanceof AxiosError && e.response?.data) {
+                return [e.response.data, e.response.status, e.response.headers];
+            }
+            throw e;
+        }
+    }
+}

package/rest/FetchClient.d.ts

@@ -0,0 +1,7 @@
+import type { HowlerResponse } from '@cccsaurora/howler-ui/api';
+import type RestClient from '@cccsaurora/howler-ui/rest';
+export default class FetchClient implements RestClient {
+    fetch<R>(url: string, method?: 'get' | 'post' | 'put' | 'delete', body?: any, params?: URLSearchParams, headers?: HeadersInit): Promise<[HowlerResponse<R>, number, {
+        [index: string]: any;
+    }]>;
+}

package/rest/FetchClient.js

@@ -0,0 +1,16 @@
+export default class FetchClient {
+    async fetch(url, method = 'get', body, params, headers) {
+        const _url = `${url}${params ? `?${params.toString()}` : ''}`;
+        const response = await fetch(_url, {
+            method,
+            credentials: 'same-origin',
+            headers: headers,
+            body: body ? JSON.stringify(body) : null
+        });
+        if (response.status === 204) {
+            return null;
+        }
+        const json = (await response.json());
+        return [json, response.status, response.headers];
+    }
+}

package/rest/index.d.ts

@@ -0,0 +1,6 @@
+import type { HowlerResponse } from '@cccsaurora/howler-ui/api';
+export default interface RestClient {
+    fetch<R>(url: string, method: 'get' | 'post' | 'put' | 'delete', body?: any, params?: URLSearchParams, headers?: HeadersInit): Promise<[HowlerResponse<R>, number, {
+        [index: string]: any;
+    }]>;
+}

package/rest/index.js

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

package/setupTests.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/vitest';