@acorex/connectivity 19.1.5 → 19.1.7

package/fesm2022/acorex-connectivity-mock.mjs

@@ -2,20 +2,20 @@ import { APPLICATION_SOURCE_NAME, MODULE_SOURCE_NAME, ENTITY_SOURCE_NAME, FEATUR
 import { AXMNotificationService } from '@acorex/modules/notification-management';
 import * as i1$1 from '@acorex/platform/auth';
 import { AXPSessionService, AXPAuthModule } from '@acorex/platform/auth';
-import { AXPDataGenerator, AXPDexieEntityStorageService, AXP_DATA_SEEDER_TOKEN, AXPEntityStorageService, AXPFileStorageStatus, AXPFileStorageService } from '@acorex/platform/common';
+import { AXPDataGenerator, AXPDexieEntityStorageService, AXP_DATA_SEEDER_TOKEN, AXPEntityStorageService, AXPFileStorageStatus, AXPFileStorageService, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
 import * as i0 from '@angular/core';
 import { inject, Injectable, NgModule } from '@angular/core';
 import { AXPEntityDefinitionRegistryService } from '@acorex/platform/layout/entity';
-import { AXMCommentService } from '@acorex/modules/backend';
 import * as i1 from '@acorex/modules/conversation';
 import { AXMConverstionModuleConst, AXMChatServiceImpl, AXMCommentServiceImpl, AXMChatModule, AXMChatService } from '@acorex/modules/conversation';
-import { AXMSchedulerJobManagementModuleConst } from '@acorex/modules/scheduler-job-management';
-import { AXMTextTemplateManagementModuleConst } from '@acorex/modules/text-template-management';
+import Dexie from 'dexie';
 import { AXP_WIDGET_DATASOURCE_PROVIDER } from '@acorex/platform/layout/builder';
 import { convertArrayToDataSource } from '@acorex/components/common';
 import { AXMFormTemplateManagementModuleConst } from '@acorex/modules/form-template-management';
-import Dexie from 'dexie';
 import { AXFileService } from '@acorex/core/file';
+import { AXMTextTemplateManagementModuleConst } from '@acorex/modules/text-template-management';
+import { AXMPlatformManagementModuleConst } from '@acorex/modules/platform-management';
+import { AXMSchedulerJobManagementModuleConst } from '@acorex/modules/scheduler-job-management';
 
 const APPLICATIONS = Array.from({ length: 5 }).map((_, i) => {
     const source = ['appOne', 'appTwo', 'appThree', 'myCoolApp', 'awesomeApp', 'superApp'];
@@ -490,10 +490,10 @@ class AXCConversationMockModule {
                 useClass: AXPCommentDataSeeder,
                 multi: true,
             },
-            {
-                provide: AXMCommentService,
-                useClass: AXMCommentMockService,
-            },
+            // {
+            //   provide: AXMCommentService,
+            //   useClass: AXMCommentMockService,
+            // },
             // {
             //   provide: AXMChatService,
             //   useClass: AXMChatMockService,
@@ -533,10 +533,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             useClass: AXPCommentDataSeeder,
                             multi: true,
                         },
-                        {
-                            provide: AXMCommentService,
-                            useClass: AXMCommentMockService,
-                        },
+                        // {
+                        //   provide: AXMCommentService,
+                        //   useClass: AXMCommentMockService,
+                        // },
                         // {
                         //   provide: AXMChatService,
                         //   useClass: AXMChatMockService,
@@ -545,6 +545,137 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
+class EntitySearchProvider {
+    async search(text) {
+        const db = new Dexie('ACoreXPlatform');
+        const lowerText = text.toLowerCase(); // Normalize search text for case-insensitive search
+        db.version(1).stores({
+            'entity-store': '++id, entityName, [entityName+id]',
+        });
+        // Fetch all records from the entity-store table
+        const allRecords = await db.table('entity-store').toArray();
+        // Filter records based on the search text
+        const filteredRecords = allRecords.filter((record) => this.shallowSearch(record, lowerText));
+        debugger;
+        return filteredRecords.map((record) => ({
+            title: record.title || '',
+            name: `record.${record.entityName}`,
+            description: record.description,
+            icon: record.icon,
+            data: record,
+        }));
+    }
+    // Helper function for shallow search
+    shallowSearch(obj, text) {
+        if (typeof obj !== 'object' || obj === null) {
+            return false;
+        }
+        return Object.entries(obj).some(([key, value]) => {
+            if (typeof value === 'string' || typeof value === 'number') {
+                return value.toString().toLowerCase().includes(text);
+            }
+            return false;
+        });
+    }
+}
+
+class AXPMockWidgetDataSourceProvider {
+    async items() {
+        return [
+            {
+                name: 'mock.users',
+                title: 'Users',
+                columns: [],
+                samples: [
+                    {
+                        id: '2',
+                        title: 'Alex Jakson',
+                    },
+                    {
+                        id: '3',
+                        title: 'Emma Smith',
+                    },
+                ],
+                source: () => convertArrayToDataSource([
+                    {
+                        id: '1',
+                        title: 'Arash Oshnoudi',
+                    },
+                    {
+                        id: '2',
+                        title: 'Alex Smith',
+                    },
+                    {
+                        id: '3',
+                        title: 'Emma Jakson',
+                    },
+                ]),
+            },
+        ];
+    }
+}
+
+class AXPFormTemplateCategoryDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.categoryEntity}`, [
+            {
+                title: 'Risk Assessment'
+            },
+            {
+                title: 'Servicing'
+            },
+            {
+                title: 'Checklists'
+            }
+        ]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+class AXCFormTemplateManagementMockModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule, providers: [
+            {
+                provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                useClass: AXPMockWidgetDataSourceProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPFormTemplateCategoryDataSeeder,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                            useClass: AXPMockWidgetDataSourceProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPFormTemplateCategoryDataSeeder,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
 class MOCKStrategy {
     constructor() { }
     get name() {
@@ -699,7 +830,7 @@ function generateNotification() {
 }
 
 const names = ['key', 'counter', 'logo', 'tenant'];
-const data = [
+const data$1 = [
     ['key1', 'string'],
     ['sequence', 'integer'],
     ['appLogo', 'function'],
@@ -710,8 +841,8 @@ const GLOBAL_VARIABLES = Array.from({ length: 4 }).map((element, i) => {
         id: AXPDataGenerator.uuid(),
         name: names[i],
         title: names[i],
-        dataType: data[i][1],
-        dataValue: data[i][0],
+        dataType: data$1[i][1],
+        dataValue: data$1[i][0],
     };
 });
 
@@ -729,6 +860,163 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
+class FileStorageDatabase extends Dexie {
+    constructor() {
+        super('FileStorageDatabase');
+        this.version(1).stores({
+            files: 'fileId,refId,refType,category,isPrimary,status',
+        });
+    }
+}
+const db = new FileStorageDatabase();
+class AXCFileStorageService {
+    async mapToFileStorageInfo(record) {
+        if (!record) {
+            throw new Error('Record not found');
+        }
+        const { binary, ...fileInfo } = record;
+        const url = await this.fileService.blobToBase64(binary);
+        return { ...fileInfo, url };
+    }
+    async save(request) {
+        const fileId = crypto.randomUUID();
+        const fileInfo = {
+            fileId,
+            refId: request.refId,
+            refType: request.refType,
+            category: request.category,
+            size: request.file.size,
+            mimeType: request.file.type,
+            uploadedAt: new Date(),
+            isPublic: request.metadata?.["isPublic"] || true,
+            isPrimary: request.isPrimary || false,
+            status: AXPFileStorageStatus.Temporary, // Use enum
+        };
+        // Save the binary content along with metadata in Dexie
+        await db.files.add({ ...fileInfo, binary: request.file });
+        return fileInfo;
+    }
+    async commit(fileId) {
+        const file = await db.files.get(fileId);
+        if (!file) {
+            throw new Error('File not found');
+        }
+        file.status = AXPFileStorageStatus.Committed; // Use enum
+        await db.files.put(file);
+    }
+    async markForDeletion(fileId) {
+        const file = await db.files.get(fileId);
+        if (!file) {
+            throw new Error('File not found');
+        }
+        file.status = AXPFileStorageStatus.PendingDeletion; // Use enum
+        await db.files.put(file);
+    }
+    async update(request) {
+        const file = await db.files.get(request.fileId);
+        if (!file) {
+            throw new Error('File not found');
+        }
+        const updatedFileInfo = {
+            ...file,
+            ...request.metadata,
+            isPrimary: request.isPrimary !== undefined ? request.isPrimary : file.isPrimary,
+        };
+        await db.files.put(updatedFileInfo);
+        return this.mapToFileStorageInfo(updatedFileInfo);
+    }
+    async find(request) {
+        const files = await db.files.toArray();
+        const filteredFiles = files.filter((file) => {
+            return ((!request.refId || file.refId === request.refId) &&
+                (!request.refType || file.refType === request.refType) &&
+                (!request.category || file.category === request.category) &&
+                (!request.isPrimary || file.isPrimary === request.isPrimary) &&
+                (!request.isPublic || file.isPublic === request.isPublic) &&
+                (!request.mimeType || file.mimeType === request.mimeType) &&
+                (!request.uploadedAtRange ||
+                    (file.uploadedAt >= request.uploadedAtRange.from &&
+                        file.uploadedAt <= request.uploadedAtRange.to)) &&
+                file.status === AXPFileStorageStatus.Committed // Use enum
+            );
+        });
+        // Map all filtered files to `AXPFileStorageInfo`
+        return Promise.all(filteredFiles.map((file) => this.mapToFileStorageInfo(file)));
+    }
+    async getInfo(fileId) {
+        // Simulate a delay of 2 seconds (2000 milliseconds)
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const file = await db.files.get(fileId);
+        return this.mapToFileStorageInfo(file);
+    }
+    async remove(fileId) {
+        await db.files.delete(fileId);
+    }
+    async cleanupTemporaryFiles() {
+        const files = await db.files.toArray();
+        const temporaryFiles = files.filter((file) => file.status === AXPFileStorageStatus.Temporary);
+        for (const file of temporaryFiles) {
+            await db.files.delete(file.fileId);
+        }
+    }
+    async cleanupMarkedFiles(gracePeriod) {
+        const now = new Date();
+        const files = await db.files.toArray();
+        for (const file of files) {
+            if (file.status === AXPFileStorageStatus.PendingDeletion &&
+                now.getTime() - file.uploadedAt.getTime() > gracePeriod) {
+                await db.files.delete(file.fileId);
+            }
+        }
+    }
+    // Semi-background cleanup job
+    constructor() {
+        this.fileService = inject(AXFileService);
+        setInterval(() => {
+            this.cleanupMarkedFiles(5 * 60 * 1000) // Grace period: 5 minutes in milliseconds
+                .catch((error) => console.error('Error during cleanup:', error));
+            this.cleanupTemporaryFiles() // Ensure temporary files are cleaned
+                .catch((error) => console.error('Error during cleanup:', error));
+        }, 5 * 60 * 1000); // Runs every 5 minutes
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileStorageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileStorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+const data = [
+    ['key1', 'string'],
+    ['sequence', 'integer'],
+    ['appLogo', 'function'],
+    ['CompanyName', 'function'],
+];
+const TEXT_SEARCH_DATA = Array.from({ length: 4 }).map((element, i) => {
+    return {
+        id: AXPDataGenerator.uuid(),
+        name: `${AXMTextTemplateManagementModuleConst.moduleName}.${AXMTextTemplateManagementModuleConst.categoryEntity}`,
+        title: data[i][0],
+        subtitle: data[i][1],
+        entityId: AXPDataGenerator.uuid(),
+        entityType: `${AXMTextTemplateManagementModuleConst.moduleName}.${AXMTextTemplateManagementModuleConst.categoryEntity}`,
+    };
+});
+
+class AXPTextSearchDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${AXMPlatformManagementModuleConst.moduleName}.${AXMPlatformManagementModuleConst.textSearchEntity}`, TEXT_SEARCH_DATA);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPTextSearchDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPTextSearchDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPTextSearchDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
 const SCHEDULER_JOB = [
     {
         id: AXPDataGenerator.uuid(),
@@ -905,229 +1193,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
-class AXPMockWidgetDataSourceProvider {
-    async items() {
-        return [
-            {
-                name: 'mock.users',
-                title: 'Users',
-                columns: [],
-                samples: [
-                    {
-                        id: '2',
-                        title: 'Alex Jakson',
-                    },
-                    {
-                        id: '3',
-                        title: 'Emma Smith',
-                    },
-                ],
-                source: () => convertArrayToDataSource([
-                    {
-                        id: '1',
-                        title: 'Arash Oshnoudi',
-                    },
-                    {
-                        id: '2',
-                        title: 'Alex Smith',
-                    },
-                    {
-                        id: '3',
-                        title: 'Emma Jakson',
-                    },
-                ]),
-            },
-        ];
-    }
-}
-
-class AXPFormTemplateCategoryDataSeeder {
-    constructor() {
-        this.storageService = inject(AXPDexieEntityStorageService);
-    }
-    async seed() {
-        await this.storageService.initial(`${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.categoryEntity}`, [
-            {
-                title: 'Risk Assessment'
-            },
-            {
-                title: 'Servicing'
-            },
-            {
-                title: 'Checklists'
-            }
-        ]);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFormTemplateCategoryDataSeeder, decorators: [{
-            type: Injectable
-        }] });
-
-class AXCFormTemplateManagementMockModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule, providers: [
-            {
-                provide: AXP_WIDGET_DATASOURCE_PROVIDER,
-                useClass: AXPMockWidgetDataSourceProvider,
-                multi: true,
-            },
-            {
-                provide: AXP_DATA_SEEDER_TOKEN,
-                useClass: AXPFormTemplateCategoryDataSeeder,
-                multi: true,
-            },
-        ] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFormTemplateManagementMockModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [],
-                    declarations: [],
-                    providers: [
-                        {
-                            provide: AXP_WIDGET_DATASOURCE_PROVIDER,
-                            useClass: AXPMockWidgetDataSourceProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_DATA_SEEDER_TOKEN,
-                            useClass: AXPFormTemplateCategoryDataSeeder,
-                            multi: true,
-                        },
-                    ],
-                }]
-        }] });
-
-class FileStorageDatabase extends Dexie {
-    constructor() {
-        super('FileStorageDatabase');
-        this.version(1).stores({
-            files: 'fileId,refId,refType,category,isPrimary,status',
-        });
-    }
-}
-const db = new FileStorageDatabase();
-class AXCFileStorageService {
-    async mapToFileStorageInfo(record) {
-        if (!record) {
-            throw new Error('Record not found');
-        }
-        const { binary, ...fileInfo } = record;
-        const url = await this.fileService.blobToBase64(binary);
-        return { ...fileInfo, url };
-    }
-    async save(request) {
-        const fileId = crypto.randomUUID();
-        const fileInfo = {
-            fileId,
-            refId: request.refId,
-            refType: request.refType,
-            category: request.category,
-            size: request.file.size,
-            mimeType: request.file.type,
-            uploadedAt: new Date(),
-            isPublic: request.metadata?.["isPublic"] || true,
-            isPrimary: request.isPrimary || false,
-            status: AXPFileStorageStatus.Temporary, // Use enum
-        };
-        // Save the binary content along with metadata in Dexie
-        await db.files.add({ ...fileInfo, binary: request.file });
-        return fileInfo;
-    }
-    async commit(fileId) {
-        const file = await db.files.get(fileId);
-        if (!file) {
-            throw new Error('File not found');
-        }
-        file.status = AXPFileStorageStatus.Committed; // Use enum
-        await db.files.put(file);
-    }
-    async markForDeletion(fileId) {
-        const file = await db.files.get(fileId);
-        if (!file) {
-            throw new Error('File not found');
-        }
-        file.status = AXPFileStorageStatus.PendingDeletion; // Use enum
-        await db.files.put(file);
-    }
-    async update(request) {
-        const file = await db.files.get(request.fileId);
-        if (!file) {
-            throw new Error('File not found');
-        }
-        const updatedFileInfo = {
-            ...file,
-            ...request.metadata,
-            isPrimary: request.isPrimary !== undefined ? request.isPrimary : file.isPrimary,
-        };
-        await db.files.put(updatedFileInfo);
-        return this.mapToFileStorageInfo(updatedFileInfo);
-    }
-    async find(request) {
-        const files = await db.files.toArray();
-        const filteredFiles = files.filter((file) => {
-            return ((!request.refId || file.refId === request.refId) &&
-                (!request.refType || file.refType === request.refType) &&
-                (!request.category || file.category === request.category) &&
-                (!request.isPrimary || file.isPrimary === request.isPrimary) &&
-                (!request.isPublic || file.isPublic === request.isPublic) &&
-                (!request.mimeType || file.mimeType === request.mimeType) &&
-                (!request.uploadedAtRange ||
-                    (file.uploadedAt >= request.uploadedAtRange.from &&
-                        file.uploadedAt <= request.uploadedAtRange.to)) &&
-                file.status === AXPFileStorageStatus.Committed // Use enum
-            );
-        });
-        // Map all filtered files to `AXPFileStorageInfo`
-        return Promise.all(filteredFiles.map((file) => this.mapToFileStorageInfo(file)));
-    }
-    async getInfo(fileId) {
-        // Simulate a delay of 2 seconds (2000 milliseconds)
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-        const file = await db.files.get(fileId);
-        return this.mapToFileStorageInfo(file);
-    }
-    async remove(fileId) {
-        await db.files.delete(fileId);
-    }
-    async cleanupTemporaryFiles() {
-        const files = await db.files.toArray();
-        const temporaryFiles = files.filter((file) => file.status === AXPFileStorageStatus.Temporary);
-        for (const file of temporaryFiles) {
-            await db.files.delete(file.fileId);
-        }
-    }
-    async cleanupMarkedFiles(gracePeriod) {
-        const now = new Date();
-        const files = await db.files.toArray();
-        for (const file of files) {
-            if (file.status === AXPFileStorageStatus.PendingDeletion &&
-                now.getTime() - file.uploadedAt.getTime() > gracePeriod) {
-                await db.files.delete(file.fileId);
-            }
-        }
-    }
-    // Semi-background cleanup job
-    constructor() {
-        this.fileService = inject(AXFileService);
-        setInterval(() => {
-            this.cleanupMarkedFiles(5 * 60 * 1000) // Grace period: 5 minutes in milliseconds
-                .catch((error) => console.error('Error during cleanup:', error));
-            this.cleanupTemporaryFiles() // Ensure temporary files are cleaned
-                .catch((error) => console.error('Error during cleanup:', error));
-        }, 5 * 60 * 1000); // Runs every 5 minutes
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileStorageService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCFileStorageService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
 class AXCMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXCMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXCMockModule, imports: [i1$1.AXPAuthModule, AXCFormTemplateManagementMockModule,
@@ -1167,6 +1232,11 @@ class AXCMockModule {
                 useClass: AXPSchedulerJobDataSeeder,
                 multi: true,
             },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPTextSearchDataSeeder,
+                multi: true,
+            },
             {
                 provide: AXPModuleDesignerService,
                 useClass: AXCModuleDesignerService,
@@ -1175,6 +1245,11 @@ class AXCMockModule {
                 provide: AXPFileStorageService,
                 useClass: AXCFileStorageService,
             },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: EntitySearchProvider,
+                multi: true,
+            },
         ], imports: [AXPAuthModule.forRoot({
                 strategies: [MOCKStrategy],
             }),
@@ -1228,6 +1303,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             useClass: AXPSchedulerJobDataSeeder,
                             multi: true,
                         },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPTextSearchDataSeeder,
+                            multi: true,
+                        },
                         {
                             provide: AXPModuleDesignerService,
                             useClass: AXCModuleDesignerService,
@@ -1236,6 +1316,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             provide: AXPFileStorageService,
                             useClass: AXCFileStorageService,
                         },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: EntitySearchProvider,
+                            multi: true,
+                        },
                     ],
                 }]
         }] });