ngx-material-entity 15.3.1 → 16.0.1

package/esm2022/components/table/table-data.builder.mjs

@@ -0,0 +1,269 @@
+import { BaseBuilder } from '../../classes/base.builder';
+import { defaultFalse } from '../../functions/default-false.function';
+import { defaultTrue } from '../../functions/default-true.function';
+import { isAsyncFunction } from '../../functions/is-async-function.function';
+import { ConfirmDialogDataBuilder } from '../confirm-dialog/confirm-dialog-data.builder';
+import { CreateDialogDataBuilder } from './create-dialog/create-dialog-data.builder';
+import { EditDialogDataBuilder } from './edit-dialog/edit-data.builder';
+/**
+ * The internal BaseTableAction. Sets default values.
+ */
+export class BaseTableActionInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    type = 'default';
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayName;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    action;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    enabled;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    requireConfirmDialog;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    confirmDialogData;
+    constructor(data) {
+        this.displayName = data.displayName;
+        this.action = this.functionToAsync(data.action);
+        this.enabled = data.enabled ?? defaultTrue;
+        this.requireConfirmDialog = data.requireConfirmDialog ?? defaultFalse;
+        this.confirmDialogData = new ConfirmDialogDataBuilder(data.confirmDialogData)
+            .withDefault('text', ['Do you really want to run this action?'])
+            .getResult();
+    }
+    functionToAsync(originalFunction) {
+        if (isAsyncFunction(originalFunction)) {
+            return originalFunction;
+        }
+        /* istanbul ignore next */
+        return () => new Promise((resolve, reject) => {
+            try {
+                resolve(originalFunction());
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+/**
+ * The internal BaseTableAction. Sets default values.
+ */
+export class MultiSelectActionInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    type = 'multi-select';
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayName;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    action;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    enabled;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    requireConfirmDialog;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    confirmDialogData;
+    constructor(data) {
+        this.displayName = data.displayName;
+        this.action = this.functionToAsync(data.action);
+        this.enabled = data.enabled ?? ((entities) => !!entities.length);
+        this.requireConfirmDialog = data.requireConfirmDialog ?? defaultFalse;
+        this.confirmDialogData = new ConfirmDialogDataBuilder(data.confirmDialogData)
+            .withDefault('text', ['Do you really want to run this action?'])
+            .getResult();
+    }
+    // eslint-disable-next-line max-len
+    functionToAsync(originalFunction) {
+        if (isAsyncFunction(originalFunction)) {
+            return originalFunction;
+        }
+        /* istanbul ignore next */
+        return (selectedEntities) => new Promise((resolve, reject) => {
+            try {
+                resolve(originalFunction(selectedEntities));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+/**
+ * The internal TableData. Requires all default values the user can leave out.
+ */
+export class TableDataInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    baseData;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    createDialogData;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    editData;
+    constructor(baseData, createDialogData, editDialogData) {
+        this.baseData = baseData;
+        this.createDialogData = createDialogData;
+        this.editData = editDialogData;
+    }
+}
+/**
+ * The Builder for the table BaseData. Sets default values.
+ */
+export class BaseDataBuilder extends BaseBuilder {
+    constructor(data) {
+        super(data);
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    generateBaseData(data) {
+        return new BaseDataInternal(data);
+    }
+}
+/**
+ * The internal TableData. Requires all default values the user can leave out.
+ */
+export class BaseDataInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    title;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayColumns;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    EntityServiceClass;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    searchLabel;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    createButtonLabel;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    defaultEdit;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    searchString;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    allowCreate;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    allowRead;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    allowUpdate;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    allowDelete;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    tableActions;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    tableActionsLabel;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayLoadingSpinner;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    allowJsonImport;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    importActionData;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    EntityClass;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    edit;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    create;
+    constructor(data) {
+        this.title = data.title;
+        this.displayColumns = data.displayColumns;
+        this.EntityServiceClass = data.EntityServiceClass;
+        this.EntityClass = data.EntityClass;
+        this.searchLabel = data.searchLabel ?? 'Search';
+        this.createButtonLabel = data.createButtonLabel ?? 'Create';
+        this.defaultEdit = data.defaultEdit ?? 'dialog';
+        this.searchString = data.searchString ?? defaultSearchFunction;
+        if (data.tableActions) {
+            this.tableActions = data.tableActions.map(tA => {
+                return tA.type === 'default' ? new BaseTableActionInternal(tA) : new MultiSelectActionInternal(tA);
+            });
+        }
+        else {
+            this.tableActions = [];
+        }
+        this.tableActionsLabel = data.tableActionsLabel ?? 'Actions';
+        this.displayLoadingSpinner = data.displayLoadingSpinner ?? true;
+        this.allowJsonImport = data.allowJsonImport ?? false;
+        this.importActionData = this.buildImportActionData(data.importActionData);
+        this.edit = data.edit;
+        this.create = data.create;
+        this.allowCreate = this.allowDataToFunction(data.allowCreate);
+        this.allowRead = this.allowDataToFunction(data.allowRead);
+        this.allowUpdate = this.allowDataToFunction(data.allowUpdate);
+        this.allowDelete = this.allowDataToFunction(data.allowDelete);
+    }
+    buildImportActionData(importActionData) {
+        importActionData = importActionData ?? {
+            displayName: 'Import (JSON)',
+            confirmDialogData: new ConfirmDialogDataBuilder()
+                .withDefault('text', ['Do you really want to import entities from the provided file?'])
+                .getResult()
+        };
+        /* istanbul ignore next */
+        const data = {
+            ...importActionData,
+            enabled: importActionData.enabled ?? defaultTrue,
+            requireConfirmDialog: defaultFalse,
+            confirmDialogData: new ConfirmDialogDataBuilder(importActionData.confirmDialogData).getResult(),
+            type: 'default'
+        };
+        return data;
+    }
+    allowDataToFunction(value) {
+        if (value == null) {
+            return defaultTrue;
+        }
+        if (typeof value == 'boolean') {
+            if (value) {
+                return defaultTrue;
+            }
+            return defaultFalse;
+        }
+        return value;
+    }
+}
+/**
+ * The Builder for the complete TableData. Sets default values and validates user input.
+ */
+export class TableDataBuilder extends BaseBuilder {
+    constructor(data) {
+        super(data);
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    generateBaseData(data) {
+        const createDialogData = new CreateDialogDataBuilder(data.createDialogData).getResult();
+        const editDialogData = new EditDialogDataBuilder(data.editData).getResult();
+        const baseData = new BaseDataBuilder(data.baseData).getResult();
+        return new TableDataInternal(baseData, createDialogData, editDialogData);
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    validateInput(data) {
+        if (data.baseData.tableActions?.length && data.baseData.displayColumns.find(dp => dp.displayName === 'select')) {
+            throw new Error(`The name "select" for a display column is reserved for the multi-select action functionality.
+                Please choose a different name.`);
+        }
+        if (!data.baseData.EntityClass
+            && (data.baseData.allowCreate !== false
+                || data.baseData.allowRead !== false
+                || data.baseData.allowUpdate !== false
+                || data.baseData.allowDelete !== false)) {
+            throw new Error(`Missing required Input data "EntityClass".
+                You can only omit this value if you can neither create, read, update or delete entities.`);
+        }
+        if (data.editData && data.baseData.defaultEdit == 'page') {
+            throw new Error(`The configured edit data can't be used, as the entity gets edited on its own page.
+                You need to provide values for the "NGX_EDIT_DATA", "NGX_EDIT_DATA_ENTITY" and "NGX_EDIT_DATA_ENTITY_SERVICE" injection keys
+                on the route where the edit page is used.`);
+        }
+    }
+}
+/**
+ * The default search function taken from googles mat table.
+ * This will be used if no custom search function is provided by the configuration.
+ *
+ * It generates a string from an entity which is then used to compare it to the search input.
+ *
+ * @param entity - An entity that is in the search.
+ * @returns The generated string of the given entity used for comparison with the search input.
+ */
+export function defaultSearchFunction(entity) {
+    const searchString = Object.keys(entity)
+        .reduce((currentTerm, key) => {
+        return `${currentTerm}${entity[key]}◬`;
+    }, '')
+        .toLowerCase();
+    return searchString;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-data.builder.js","sourceRoot":"","sources":["../../../../../projects/ngx-material-entity/src/components/table/table-data.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { BaseBuilder } from '../../classes/base.builder';\nimport { BaseEntityType, EntityClassNewable } from '../../classes/entity.model';\nimport { defaultFalse } from '../../functions/default-false.function';\nimport { defaultTrue } from '../../functions/default-true.function';\nimport { isAsyncFunction } from '../../functions/is-async-function.function';\nimport { EntityService } from '../../services/entity.service';\nimport { ConfirmDialogDataBuilder, ConfirmDialogDataInternal } from '../confirm-dialog/confirm-dialog-data.builder';\nimport { CreateDialogDataBuilder, CreateDialogDataInternal } from './create-dialog/create-dialog-data.builder';\nimport { EditDataInternal, EditDialogDataBuilder } from './edit-dialog/edit-data.builder';\nimport { BaseData, BaseTableAction, DisplayColumn, MultiSelectAction, TableData } from './table-data';\n\n/**\n * The internal BaseTableAction. Sets default values.\n */\nexport class BaseTableActionInternal implements BaseTableAction {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    type: 'default' = 'default';\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayName: string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    action: () => Promise<unknown>;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    enabled: (() => boolean);\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    requireConfirmDialog: (() => boolean);\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    confirmDialogData: ConfirmDialogDataInternal;\n\n    constructor(data: BaseTableAction) {\n        this.displayName = data.displayName;\n        this.action = this.functionToAsync(data.action);\n        this.enabled = data.enabled ?? defaultTrue;\n        this.requireConfirmDialog = data.requireConfirmDialog ?? defaultFalse;\n        this.confirmDialogData = new ConfirmDialogDataBuilder(data.confirmDialogData)\n            .withDefault('text', ['Do you really want to run this action?'])\n            .getResult();\n    }\n\n    private functionToAsync(originalFunction: (() => unknown) | (() => Promise<unknown>)): () => Promise<unknown> {\n        if (isAsyncFunction(originalFunction)) {\n            return originalFunction as () => Promise<unknown>;\n        }\n\n        /* istanbul ignore next */\n        return () => new Promise<unknown>((resolve, reject) => {\n            try {\n                resolve(originalFunction());\n            }\n            catch (error) {\n                reject(error);\n            }\n        });\n    }\n}\n\n/**\n * The internal BaseTableAction. Sets default values.\n */\nexport class MultiSelectActionInternal<EntityType extends BaseEntityType<EntityType>> implements MultiSelectAction<EntityType> {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    type: 'multi-select' = 'multi-select';\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayName: string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    action: (selectedEntities: EntityType[]) => Promise<unknown>;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    enabled: ((selectedEntities: EntityType[]) => boolean);\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    requireConfirmDialog: ((selectedEntities: EntityType[]) => boolean);\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    confirmDialogData: ConfirmDialogDataInternal;\n\n    constructor(data: MultiSelectAction<EntityType>) {\n        this.displayName = data.displayName;\n        this.action = this.functionToAsync(data.action);\n        this.enabled = data.enabled ?? ((entities: EntityType[]) => !!entities.length);\n        this.requireConfirmDialog = data.requireConfirmDialog ?? defaultFalse;\n        this.confirmDialogData = new ConfirmDialogDataBuilder(data.confirmDialogData)\n            .withDefault('text', ['Do you really want to run this action?'])\n            .getResult();\n    }\n\n    // eslint-disable-next-line max-len\n    private functionToAsync(originalFunction: ((selectedEntities: EntityType[]) => unknown) | ((selectedEntities: EntityType[]) => Promise<unknown>)): (selectedEntities: EntityType[]) => Promise<unknown> {\n        if (isAsyncFunction(originalFunction)) {\n            return originalFunction as (selectedEntities: EntityType[]) => Promise<unknown>;\n        }\n\n        /* istanbul ignore next */\n        return (selectedEntities: EntityType[]) => new Promise<unknown>((resolve, reject) => {\n            try {\n                resolve(originalFunction(selectedEntities));\n            }\n            catch (error) {\n                reject(error);\n            }\n        });\n    }\n}\n\n/**\n * The Internal Table Action. Sets default values.\n */\nexport type TableActionInternal<EntityType extends BaseEntityType<EntityType>> =\n    BaseTableActionInternal | MultiSelectActionInternal<EntityType>;\n\n/**\n * The internal TableData. Requires all default values the user can leave out.\n */\nexport class TableDataInternal<EntityType extends BaseEntityType<EntityType>> implements TableData<EntityType> {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    baseData: BaseDataInternal<EntityType>;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    createDialogData: CreateDialogDataInternal;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    editData: EditDataInternal<EntityType>;\n\n    constructor(\n        baseData: BaseDataInternal<EntityType>,\n        createDialogData: CreateDialogDataInternal,\n        editDialogData: EditDataInternal<EntityType>\n    ) {\n        this.baseData = baseData;\n        this.createDialogData = createDialogData;\n        this.editData = editDialogData;\n    }\n}\n\n/**\n * The Builder for the table BaseData. Sets default values.\n */\nexport class BaseDataBuilder<EntityType extends BaseEntityType<EntityType>>\n    extends BaseBuilder<BaseDataInternal<EntityType>, BaseData<EntityType>> {\n\n    constructor(data: BaseData<EntityType>) {\n        super(data);\n    }\n\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    protected generateBaseData(data: BaseData<EntityType>): BaseDataInternal<EntityType> {\n        return new BaseDataInternal<EntityType>(data);\n    }\n}\n\n/**\n * The internal TableData. Requires all default values the user can leave out.\n */\nexport class BaseDataInternal<EntityType extends BaseEntityType<EntityType>> implements BaseData<EntityType> {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    title: string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayColumns: DisplayColumn<EntityType>[];\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    EntityServiceClass: new (httpClient: HttpClient) => EntityService<EntityType>;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    searchLabel: string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    createButtonLabel: string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    defaultEdit: 'dialog' | 'page';\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    searchString: (entity: EntityType) => string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    allowCreate: () => boolean;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    allowRead: (entity?: EntityType) => boolean;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    allowUpdate: (entity?: EntityType) => boolean;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    allowDelete: (entity?: EntityType) => boolean;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    tableActions: TableActionInternal<EntityType>[];\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    tableActionsLabel: string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayLoadingSpinner: boolean;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    allowJsonImport: boolean;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    importActionData: Omit<BaseTableActionInternal, 'action'>;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    EntityClass?: EntityClassNewable<EntityType>;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    edit?: (entity: EntityType) => unknown;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    create?: (entity: EntityType) => unknown;\n\n    constructor(data: BaseData<EntityType>) {\n        this.title = data.title;\n        this.displayColumns = data.displayColumns;\n        this.EntityServiceClass = data.EntityServiceClass;\n        this.EntityClass = data.EntityClass;\n        this.searchLabel = data.searchLabel ?? 'Search';\n        this.createButtonLabel = data.createButtonLabel ?? 'Create';\n        this.defaultEdit = data.defaultEdit ?? 'dialog';\n        this.searchString = data.searchString ?? defaultSearchFunction;\n        if (data.tableActions) {\n            this.tableActions = data.tableActions.map(tA => {\n                return tA.type === 'default' ? new BaseTableActionInternal(tA) : new MultiSelectActionInternal(tA);\n            });\n        }\n        else {\n            this.tableActions = [];\n        }\n        this.tableActionsLabel = data.tableActionsLabel ?? 'Actions';\n        this.displayLoadingSpinner = data.displayLoadingSpinner ?? true;\n        this.allowJsonImport = data.allowJsonImport ?? false;\n        this.importActionData = this.buildImportActionData(data.importActionData);\n        this.edit = data.edit;\n        this.create = data.create;\n        this.allowCreate = this.allowDataToFunction(data.allowCreate);\n        this.allowRead = this.allowDataToFunction(data.allowRead);\n        this.allowUpdate = this.allowDataToFunction(data.allowUpdate);\n        this.allowDelete = this.allowDataToFunction(data.allowDelete);\n    }\n\n    private buildImportActionData(\n        importActionData?: Omit<BaseTableAction, 'action' | 'requireConfirmDialog' | 'type'>\n    ): Omit<BaseTableActionInternal, 'action'> {\n        importActionData = importActionData ?? {\n            displayName: 'Import (JSON)',\n            confirmDialogData: new ConfirmDialogDataBuilder()\n                .withDefault('text', ['Do you really want to import entities from the provided file?'])\n                .getResult()\n        };\n        /* istanbul ignore next */\n        const data: Omit<BaseTableActionInternal, 'action'> = {\n            ...importActionData,\n            enabled: importActionData.enabled ?? defaultTrue,\n            requireConfirmDialog: defaultFalse,\n            confirmDialogData: new ConfirmDialogDataBuilder(importActionData.confirmDialogData).getResult(),\n            type: 'default'\n        };\n        return data;\n    }\n\n    private allowDataToFunction(value?: boolean | ((entity?: EntityType) => boolean)): ((entity?: EntityType) => boolean) {\n        if (value == null) {\n            return defaultTrue;\n        }\n        if (typeof value == 'boolean') {\n            if (value) {\n                return defaultTrue;\n            }\n            return defaultFalse;\n        }\n        return value;\n    }\n}\n\n/**\n * The Builder for the complete TableData. Sets default values and validates user input.\n */\nexport class TableDataBuilder<EntityType extends BaseEntityType<EntityType>>\n    extends BaseBuilder<TableDataInternal<EntityType>, TableData<EntityType>> {\n\n    constructor(data: TableData<EntityType>) {\n        super(data);\n    }\n\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    protected generateBaseData(data: TableData<EntityType>): TableDataInternal<EntityType> {\n        const createDialogData: CreateDialogDataInternal = new CreateDialogDataBuilder(data.createDialogData).getResult();\n        const editDialogData: EditDataInternal<EntityType> = new EditDialogDataBuilder(data.editData).getResult();\n        const baseData: BaseDataInternal<EntityType> = new BaseDataBuilder(data.baseData).getResult();\n        return new TableDataInternal<EntityType>(\n            baseData,\n            createDialogData,\n            editDialogData\n        );\n    }\n\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    protected override validateInput(data: TableData<EntityType>): void {\n        if (data.baseData.tableActions?.length && data.baseData.displayColumns.find(dp => dp.displayName === 'select')) {\n            throw new Error(\n                `The name \"select\" for a display column is reserved for the multi-select action functionality.\n                Please choose a different name.`\n            );\n        }\n        if (\n            !data.baseData.EntityClass\n            && (\n                data.baseData.allowCreate !== false\n                || data.baseData.allowRead !== false\n                || data.baseData.allowUpdate !== false\n                || data.baseData.allowDelete !== false\n            )\n        ) {\n            throw new Error(\n                `Missing required Input data \"EntityClass\".\n                You can only omit this value if you can neither create, read, update or delete entities.`\n            );\n        }\n        if (data.editData && data.baseData.defaultEdit == 'page') {\n            throw new Error(\n                `The configured edit data can't be used, as the entity gets edited on its own page.\n                You need to provide values for the \"NGX_EDIT_DATA\", \"NGX_EDIT_DATA_ENTITY\" and \"NGX_EDIT_DATA_ENTITY_SERVICE\" injection keys\n                on the route where the edit page is used.`\n            );\n        }\n    }\n}\n\n/**\n * The default search function taken from googles mat table.\n * This will be used if no custom search function is provided by the configuration.\n *\n * It generates a string from an entity which is then used to compare it to the search input.\n *\n * @param entity - An entity that is in the search.\n * @returns The generated string of the given entity used for comparison with the search input.\n */\nexport function defaultSearchFunction<EntityType extends BaseEntityType<EntityType>>(entity: EntityType): string {\n    const searchString: string = Object.keys(entity)\n        .reduce((currentTerm: string, key: string) => {\n            return `${currentTerm}${(entity as Record<string, unknown>)[key]}◬`;\n        }, '')\n        .toLowerCase();\n    return searchString;\n}"]}