@zeedhi/teknisa-components-common 3.1.0 → 3.2.0

package/tests/__helpers__/flush-promises-helper.ts

@@ -1,3 +0,0 @@
-const flushPromises = () => (new Promise(setImmediate));
-
-export { flushPromises };

package/tests/__helpers__/get-child-helper.ts

@@ -1,27 +0,0 @@
-import type { IComponent } from '@zeedhi/common';
-
-/**
- * Search for a component inside an array of children
- *
- * The children array can be either an array of IComponent or an array of Component
- */
-const getChild = <T extends IComponent>(children: any[], name: string): T => {
-  let found: any;
-
-  children.forEach((child) => {
-    if (child.name === name) {
-      found = child;
-      return;
-    }
-
-    if (child.children && child.children.length > 0) {
-      const result = getChild<T>(child.children, name) as T;
-
-      if (result) found = result;
-    }
-  });
-
-  return found;
-};
-
-export { getChild };

package/tests/__helpers__/index.ts

@@ -1,7 +0,0 @@
-export * from './component-event-helper';
-export * from './get-child-helper';
-export * from './mock-created-helper';
-export * from './spy-on-all-methods';
-export * from './flush-promises-helper';
-export * from './create-component';
-export * from './find-component';

package/tests/__helpers__/mock-created-helper.ts

@@ -1,12 +0,0 @@
-import type { ComponentRender } from '@zeedhi/common';
-
-/**
- * Function used to spy on a class' onCreated and always assign the componentId as 1
- */
-const mockCreated = <T extends ComponentRender>(component: T, prototype: any) => {
-  jest.spyOn(prototype, 'onCreated').mockImplementation(() => {
-    component.componentId = 1;
-  });
-};
-
-export { mockCreated };

package/tests/__helpers__/spy-on-all-methods.ts

@@ -1,46 +0,0 @@
-import { IDictionary } from "@zeedhi/core";
-
-// add a spy on all methods from a class prototype
-const spyOnAllMethods = (
-  prototype: any,
-  mockImplementations: IDictionary = {},
-  alreadySpiedMethods: Set<string> = new Set(),
-  depth: number = 0,
-  maxDepth: number = 10 // Safety limit
-) => {
-  // Safety check against infinite recursion
-  if (depth > maxDepth || prototype === null || prototype === Object.prototype) {
-    return {};
-  }
-
-  const methods = Object.getOwnPropertyNames(prototype).filter(
-    (prop) => typeof prototype[prop] === 'function' && prop !== 'constructor'
-  );
-
-  const spyObj: IDictionary<jest.SpyInstance> = {};
-
-  methods.forEach((method) => {
-    if (!alreadySpiedMethods.has(method)) {
-      const mockImplementation = mockImplementations[method] || jest.fn();
-      spyObj[method] = jest.spyOn(prototype, method).mockImplementation(mockImplementation);
-      alreadySpiedMethods.add(method);
-    }
-  });
-
-  // Get the parent prototype carefully
-  const parentPrototype = Object.getPrototypeOf(prototype);
-  if (parentPrototype && parentPrototype !== prototype) { // Additional check to prevent cycles
-    const parentSpyObj = spyOnAllMethods(
-      parentPrototype,
-      mockImplementations,
-      alreadySpiedMethods,
-      depth + 1,
-      maxDepth
-    );
-    Object.assign(spyObj, parentSpyObj);
-  }
-
-  return spyObj;
-};
-
-export { spyOnAllMethods };

package/tests/__mocks__/@zeedhi/core/i18n.js

@@ -1,75 +0,0 @@
-/**
- * Mock for @zeedhi/core I18n API
- */
-
-const words = {
-  TEKGRID_CONTAINS: 'contains',
-  TEKGRID_NOT_CONTAINS: 'does not contain',
-  TEKGRID_EQUALS: 'is equal to',
-  TEKGRID_NOT_EQUALS: 'is different from',
-  TEKGRID_GREATER_THAN: 'is greater than',
-  TEKGRID_LESS_THAN: 'is less than',
-  TEKGRID_GREATER_THAN_EQUALS: 'is greater or equals to',
-  TEKGRID_LESS_THAN_EQUALS: 'is less or equals to',
-  TEKGRID_IN: 'is in',
-  TEKGRID_NOT_IN: 'is not in',
-  TEKGRID_BETWEEN: 'is between',
-  TEKGRID_AND: 'and',
-  TEKGRID_OR: 'or',
-  TEKGRID_ADD: 'Add',
-  TEKGRID_DELETE: 'Delete',
-  TEKGRID_REFRESH: 'Refresh',
-  TEKGRID_COLUMNS: 'Columns',
-  TEKGRID_SAVE: 'Save',
-  TEKGRID_CANCEL: 'Cancel',
-  TEKGRID_FILTER: 'Filter',
-  TEKGRID_MULTIPLE_VALUE_HINT: 'Separate values using ";"',
-  TEKGRID_EXPORT: 'Export',
-  TEKGRID_EXPORT_AS: 'Export as {{type}}',
-  TEKGRID_COLUMN_VISIBLE: 'Visible',
-  TEKGRID_COLUMN_GROUPED: 'Grouped',
-  TEKGRID_COLUMN_AGGREGATION: 'Aggregation',
-  TEKGRID_AGGREGATION_SUM: 'Sum',
-  TEKGRID_AGGREGATION_AVG: 'Average',
-  TEKGRID_AGGREGATION_MAX: 'Maximum',
-  TEKGRID_AGGREGATION_MIN: 'Minimum',
-  TEKGRID_AGGREGATION_COUNT: 'Count',
-  NO_NOTIFICATIONS: 'No Notifications',
-  MARK_ALL_AS_READ: 'Mark all as read',
-  NOTIFICATIONS: 'Notifications',
-  SEE_ALL_NOTIFICATIONS: 'See all notifications',
-  UNAVAILABLE_IMAGE: 'Unavailable image',
-  REFRESH: 'Refresh',
-  ACTIONS: 'Actions',
-  FILTER: 'Filter',
-  LAYOUT: 'Layout: ',
-  NEW_LAYOUT: 'New layout',
-  DEFAULT_LAYOUT: 'Default',
-};
-
-const notImplemented = (name, isMethod = true) => {
-  const member = isMethod ? `I18n.${name}() method` : `I18n.${name} property`;
-  throw new Error(`The ${member} is not yet implemented/mocked by the mock in 'tests/__mocks__/@zeedhi/core/i18n.ts'.`);
-}
-
-const mock = {
-  translate: (value, variables) => {
-    let result = words[value] || value;
-    const keys = variables ? Object.keys(variables) : undefined;
-    if (keys) {
-      keys.forEach((key) => {
-        result = result.replace(`{{${key}}}`, variables[key]);
-      });
-    }
-
-    return result;
-  },
-  registerChangeListener: () => notImplemented('registerChangeListener'),
-  unregisterChangeListener: () => notImplemented('unregisterChangeListener'),
-  init: () => notImplemented('init'),
-  changeLanguage: () => notImplemented('changeLanguage'),
-  get instance() { return { language: 'en-US'} },
-  set instance(_value) { notImplemented('instance setter') },
-}
-
-module.exports = mock;

package/tests/__mocks__/@zeedhi/core.js

@@ -1,5 +0,0 @@
-const core = jest.requireActual('@zeedhi/core');
-
-core.I18n = require('./core/i18n');
-
-module.exports = core;

package/tests/unit/components/tek-breadcrumb-header/tek-breadcrumb-header.spec.ts

@@ -1,43 +0,0 @@
-import { BreadcrumbHeader } from '../../../../src';
-import { Image } from '@zeedhi/common';
-
-describe('BreadcrumbHeader', () => {
-  describe('constructor()', () => {
-    it('should create new BreadcrumbHeader with default values', () => {
-      const instance = new BreadcrumbHeader({
-        name: 'BreadcrumbHeader',
-        component: 'TekBreadcrumbHeader',
-        title: '',
-        breadcrumb: {
-          name: 'breadcrumb',
-          component: 'ZdBreadcrumb',
-          divider: '>',
-        },
-      });
-      expect(instance.title).toBe('');
-      expect(instance.rightSlot).toStrictEqual([]);
-    });
-
-    it('should create new BreadcrumbHeader with rightSlot values', () => {
-      const image = new Image({
-        name: 'image',
-        component: 'tekImage',
-        src: '/img/zeedhi.svg',
-        to: 'google.com.br',
-      });
-      const instance = new BreadcrumbHeader({
-        name: 'BreadcrumbHeader',
-        component: 'TekBreadcrumbHeader',
-        title: '',
-        breadcrumb: {
-          name: 'breadcrumb',
-          component: 'ZdBreadcrumb',
-          divider: '>',
-        },
-        rightSlot: [image],
-      });
-      expect(instance.title).toBe('');
-      expect(instance.rightSlot).toEqual([image]);
-    });
-  });
-});

package/tests/unit/components/tek-datasource/memory-datasource.spec.ts

@@ -1,463 +0,0 @@
-import {
-  init,
-  Router,
-  URL,
-} from '@zeedhi/core';
-import {
-  TekMemoryDatasource, type ITekMemoryDatasource,
-} from '../../../../src';
-import { flushPromises } from '../../../__helpers__';
-
-describe('TekMemoryDatasource', () => {
-  init({
-    controllers: {
-      AppController: class AppController {
-        public value = '1';
-      },
-    },
-  });
-
-  let datasource: ITekMemoryDatasource;
-  let router: any;
-
-  beforeEach(() => {
-    datasource = {
-      uniqueKey: 'id',
-      data: [
-        { name: 'name 1', id: 1 }, { name: 'name 2', id: 2 }, { name: 'name 3', id: 3 },
-        { name: 'name 4', id: 4 }, { name: 'name 5', id: 5 }, { name: 'name 6', id: 6 },
-      ],
-    };
-    router = {
-      push: () => jest.fn,
-      replace: (route: any) => {
-        window.history.replaceState(null, '', `${window.location.pathname}?${URL.getFormattedQueryString(route.query)}`);
-      },
-      back: () => jest.fn,
-      getCurrentRoute: () => ({
-        path: '',
-        hash: '',
-        query: {},
-        params: {},
-        fullPath: '',
-      }),
-      getPath: () => '',
-      getHash: () => '',
-      getQuery: () => ({}),
-      getParams: () => ({}),
-      getFullPath: () => '',
-    };
-    Router.setInstance(router);
-  });
-
-  describe('constuctor()', () => {
-    it('should assign all properties', async () => {
-      const flushPromises = () => new Promise(setImmediate);
-      const instance = new TekMemoryDatasource({
-        ...datasource,
-        dynamicFilter: {
-          name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }],
-        },
-        searchJoin: { col1: ['1', '2'], col2: [2], col3: [] },
-      });
-      await flushPromises();
-
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
-    });
-
-    it('should assign all properties with accessor', async () => {
-      const flushPromises = () => new Promise(setImmediate);
-      const instance = new TekMemoryDatasource({
-        ...datasource,
-        dynamicFilter: {
-          name: [{ operation: 'EQUALS', relation: 'AND', value: '{{AppController.value}}' }],
-        },
-        searchJoin: { col1: ['1', '2'], col2: [2], col3: [] },
-      });
-      await flushPromises();
-
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
-    });
-
-    it('should create using default parameters', async () => {
-      const instance = new TekMemoryDatasource({});
-
-      expect(instance.dynamicFilter).toEqual({});
-      expect(instance.searchJoin).toEqual({});
-    });
-
-    it('should set values from url', () => {
-      router.getFullPath = () => 'localhost/?page=2&limit=10&order=id.asc&search=2&id=1';
-      const instance = new TekMemoryDatasource({
-        ...datasource,
-        watchUrl: true,
-      });
-      expect(instance.filter).toEqual({ id: '1' });
-      expect(instance.limit).toBe(10);
-      expect(instance.order).toEqual(['id.asc']);
-      expect(instance.page).toBe(2);
-      expect(instance.search).toBe('2');
-    });
-
-    it('should set dynamicFilter from url', () => {
-      router.getFullPath = () => 'localhost/?dynamic_filter=eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0='; // eslint-disable-line max-len
-      datasource.watchUrl = true;
-      const instance = new TekMemoryDatasource(datasource);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-    });
-
-    it('should set searchJoin from url', () => {
-      router.getFullPath = () => 'localhost/?search_join=eyAiY29sMSI6IFsiMSIsICIyIl0sICJjb2wyIjogWzJdLCAiY29sMyI6IFtdIH0='; // eslint-disable-line max-len
-      datasource.watchUrl = true;
-      const instance = new TekMemoryDatasource(datasource);
-      expect(instance.searchJoin).toEqual({ col1: ['1', '2'], col2: [2], col3: [] });
-    });
-  });
-
-  describe('dynamicFilter', () => {
-    it('should retrieve data using dynamic filter', async () => {
-      const flushPromises = () => new Promise(setImmediate);
-      datasource.watchUrl = false;
-      const instance = new TekMemoryDatasource(datasource);
-      instance.initialize();
-
-      await flushPromises();
-      expect(instance.data.length).toBe(6);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'CONTAINS', relation: 'AND', value: '1' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(1);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'CONTAINS', relation: 'AND', value: 'name' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(6);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'CONTAINS', relation: 'AND', value: '1' },
-          { operation: 'CONTAINS', relation: 'OR', value: '2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(2);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'CONTAINS', relation: 'AND', value: '1' },
-          { operation: 'CONTAINS', relation: 'AND', value: '2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(0);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'CONTAINS', relation: 'AND', value: '1' },
-        ],
-        id: [
-          { operation: 'CONTAINS', relation: 'OR', value: '2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(2);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'NOT_CONTAINS', relation: 'AND', value: '1' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(5);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'EQUALS', relation: 'AND', value: '1' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(0);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'EQUALS', relation: 'AND', value: 'name 1' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(1);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'NOT_EQUALS', relation: 'AND', value: 'name 1' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(5);
-
-      instance.dynamicFilter = {
-        id: [
-          { operation: 'GREATER_THAN', relation: 'AND', value: '2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(4);
-
-      instance.dynamicFilter = {
-        id: [
-          { operation: 'LESS_THAN', relation: 'AND', value: '2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(1);
-
-      instance.dynamicFilter = {
-        id: [
-          { operation: 'GREATER_THAN_EQUALS', relation: 'AND', value: '2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(5);
-
-      instance.dynamicFilter = {
-        id: [
-          { operation: 'LESS_THAN_EQUALS', relation: 'AND', value: '2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(2);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'GREATER_THAN', relation: 'AND', value: 'name 2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(4);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'LESS_THAN', relation: 'AND', value: 'name 2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(1);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'GREATER_THAN_EQUALS', relation: 'AND', value: 'name 2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(5);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'LESS_THAN_EQUALS', relation: 'AND', value: 'name 2' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(2);
-
-      instance.dynamicFilter = {
-        id: [
-          { operation: 'IN', relation: 'AND', value: ['1', '2'] },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(2);
-
-      instance.dynamicFilter = {
-        id: [
-          { operation: 'NOT_IN', relation: 'AND', value: ['1', '2'] },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(4);
-
-      instance.dynamicFilter = {
-        id: [
-          { operation: 'BETWEEN', relation: 'AND', value: ['2', '5'] },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(4);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'BETWEEN', relation: 'AND', value: ['name 2', 'name 5'] },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(4);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: '', relation: 'AND', value: ['1', '2'] },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(0);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: '', relation: 'AND', value: '1' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(0);
-    });
-
-    it('should not retrieve data with wrong operator', async () => {
-      const flushPromises = () => new Promise(setImmediate);
-      const instance = new TekMemoryDatasource(datasource);
-
-      await flushPromises();
-      expect(instance.data.length).toBe(6);
-
-      instance.dynamicFilter = {
-        name: [
-          { operation: 'TEST', relation: 'AND', value: '1' },
-        ],
-      };
-      await instance.get();
-      expect(instance.data.length).toBe(0);
-    });
-  });
-
-  describe('searchJoin', () => {
-    it('should retrieve data using search join', async () => {
-      const instance = new TekMemoryDatasource(datasource);
-      instance.initialize();
-
-      await flushPromises();
-      expect(instance.data.length).toBe(6);
-
-      instance.searchJoin = {
-        name: ['name 1', 'name 2'],
-      };
-      instance.search = 'aaa';
-      await instance.get();
-      expect(instance.data.length).toBe(2);
-    });
-  });
-
-  describe('addDynamicFilter()', () => {
-    it('should add/remove dynamic filter value', () => {
-      const instance = new TekMemoryDatasource(datasource);
-      instance.addDynamicFilter('name', [{ operation: 'EQUALS', relation: 'AND', value: '1' }]);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      instance.addDynamicFilter('name', [{ operation: 'foo', relation: 'AND', value: '1' }]);
-      expect(instance.dynamicFilter).toEqual({});
-    });
-  });
-
-  describe('setDynamicFilter()', () => {
-    it('should add/remove dynamic filter value', () => {
-      const instance = new TekMemoryDatasource(datasource);
-      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-
-      instance.setDynamicFilter({ name: [{ operation: 'foo', relation: 'AND', value: '1' }] });
-      expect(instance.dynamicFilter).toEqual({});
-
-      instance.setDynamicFilter({
-        name: [], id: [{}],
-      });
-      expect(instance.dynamicFilter).toEqual({});
-    });
-
-    it('should add dynamic filter value with watchUrl', () => {
-      let dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0=';
-      router.getFullPath = () => `localhost/?dynamic_filter=${dynamicFilterValue}`;
-      const urlSpy = jest.spyOn(URL, 'updateQueryString');
-
-      datasource.watchUrl = true;
-      const instance = new TekMemoryDatasource(datasource);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-
-      dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMiJ9XX0=';
-      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
-      expect(urlSpy).toHaveBeenCalledWith({
-        dynamic_filter: dynamicFilterValue,
-      });
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
-      urlSpy.mockClear();
-    });
-  });
-
-  describe('clearDynamicFilter()', () => {
-    it('should clear dynamic filter', () => {
-      datasource.watchUrl = false;
-      const instance = new TekMemoryDatasource(datasource);
-      instance.setDynamicFilter({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-      instance.clearDynamicFilter();
-      expect(instance.dynamicFilter).toEqual({});
-    });
-
-    it('should clear dynamic filter value with watchUrl', () => {
-      let dynamicFilterValue = 'eyJuYW1lIjpbeyJvcGVyYXRpb24iOiJFUVVBTFMiLCJyZWxhdGlvbiI6IkFORCIsInZhbHVlIjoiMSJ9XX0=';
-      router.getFullPath = () => `localhost/?dynamic_filter=${dynamicFilterValue}`;
-      const urlSpy = jest.spyOn(URL, 'updateQueryString');
-
-      datasource.watchUrl = true;
-      const instance = new TekMemoryDatasource(datasource);
-      expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '1' }] });
-
-      dynamicFilterValue = '';
-      instance.clearDynamicFilter();
-      expect(urlSpy).toHaveBeenCalledWith({
-        dynamic_filter: undefined,
-      });
-      expect(instance.dynamicFilter).toEqual({});
-      urlSpy.mockClear();
-    });
-  });
-
-  describe('clone', () => {
-    it('should return an object with all datasource props', async () => {
-      const data = [{ value: 'item 1' }];
-      const dynamicFilter = {
-        name: { operation: 'EQUALS', relation: 'AND', value: 'item 1' },
-      };
-      const searchJoin = { col1: ['1', '2'], col2: [2], col3: [] };
-      const instance = new TekMemoryDatasource({
-        route: '/zeedhi',
-        data,
-        dynamicFilter,
-        searchJoin,
-      });
-      instance.initialize();
-
-      const props = instance.clone();
-
-      expect(props).toEqual({
-        data,
-        dynamicFilter,
-        searchJoin,
-        currentRow: {},
-        filter: {},
-        limit: 10,
-        order: [],
-        page: 1,
-        search: '',
-        searchIn: [],
-        uniqueKey: 'id',
-        watchUrl: false,
-        events: {},
-        loadAll: false,
-        type: 'tek-memory',
-        translate: false,
-      });
-    });
-  });
-});