pixel-react 1.9.1 → 1.9.2

package/src/components/TableTree/Components/TableCell.tsx

@@ -4,23 +4,37 @@ import RadioButton from '../../RadioButton';
 import { TableCellProps } from '../types';
 import Arrow from '../../../assets/icons/arrows_down_icon.svg?react';
 import React from 'react';
+import { checkEmpty } from '../../../utils/checkEmpty/checkEmpty';
 
 const renderSpaces = (
   level: number,
   parentSiblings: boolean[],
   isLast?: boolean | undefined
-) => (
-  <div className="tree-table-space-container">
-    {parentSiblings.reverse().map((line, i) => (
-      <span
-        key={i}
-        className={`tree-table-space-block ${!line ? 'no-lines' : ''} ${
-          isLast && i === level - 1 ? 'last-node' : ''
-        }`}
-      />
-    ))}
-  </div>
-);
+) => {
+  let siblingsArray = parentSiblings;
+  let isLastNode = isLast;
+  if (checkEmpty(parentSiblings)) {
+    isLastNode = false;
+
+    if (!isNaN(level)) {
+      siblingsArray = Array(level).fill(true);
+    }
+  }
+
+  parentSiblings;
+  return (
+    <div className="tree-table-space-container">
+      {siblingsArray.reverse().map((line, i) => (
+        <span
+          key={i}
+          className={`tree-table-space-block ${!line ? 'no-lines' : ''} ${
+            isLastNode && i === level - 1 ? 'last-node' : ''
+          }`}
+        />
+      ))}
+    </div>
+  );
+};
 
 const TableCell = React.memo(
   ({

package/src/components/TableTree/TableTree.tsx

@@ -16,23 +16,26 @@ const TreeTable: React.FC<TreeTableProps> = ({
   onExpand,
   loadMore = () => {},
 }) => {
-  useIntersectionObserver(['ff-table-tree-last-node'], {
-    root: null,
-    rootMargin: '0px',
-    threshold: 0.1,
-    onIntersect: (entry) => {
-      if (entry.isIntersecting) {
-        if (functionCheck(loadMore)) {
-          let direction = 'up';
-          if (entry.target.id === 'ff-table-tree-last-node') {
-            direction = 'down';
+  useIntersectionObserver(
+    ['ff-table-tree-last-node', 'ff-table-tree-first-node'],
+    {
+      root: null,
+      rootMargin: '0px',
+      threshold: 0.1,
+      onIntersect: (entry) => {
+        if (entry.isIntersecting) {
+          if (functionCheck(loadMore)) {
+            let direction = 'up';
+            if (entry.target.id === 'ff-table-tree-last-node') {
+              direction = 'down';
+            }
+            loadMore(direction);
           }
-          loadMore(direction);
+          console.log('Element in view:', entry.target.id);
         }
-        console.log('Element in view:', entry.target.id);
-      }
-    },
-  });
+      },
+    }
+  );
 
   const handleToggleExpand = useCallback(
     (node: any) => onExpand?.(true, node?.id),

package/src/components/TableTree/data.ts

@@ -31,37 +31,6 @@ const data = [
     isLast: true,
     parentSiblings: [true],
   },
-  {
-    node: {
-      subModuleCount: 15,
-      title: 'mod1',
-      scriptCount: 0,
-      path: '/Root',
-      expanded: true,
-      modifiedOn: '19-12-2023 15:32',
-      children: false,
-      lastExecutionOrder: 3,
-      imported: false,
-      modifiedBy: '--',
-      moduleCountWithScript: 1,
-      state: 'NEW',
-      key: 'MOD1001',
-      ver: 1,
-      hierarchy: 0,
-      assigneeCount: 0,
-      searchKey: '/MOD1001111110000000000',
-      modifiedByUname: '--',
-      executionOrder: 0,
-      createdByUname: 'Shivaprasad',
-      folder: true,
-      moduleLevelScriptCount: 0,
-      name: 'Root Module',
-      parentId: 'MOD1001', // Root has no parent
-      id: 'MOD1002', // Unique ID
-    },
-    parentSiblings: [true, false],
-    lines: 1,
-  },
   {
     node: {
       subModuleCount: 10,

package/src/utils/indexDBStore/indexDB.ts

@@ -1,37 +1,67 @@
-import { openDB, DBSchema } from 'idb';
-
-// Define the database schema
-interface MyDB extends DBSchema {
-  items: {
-    key: string; // Key for each item
-    value: string; // Stored value, encoded as a string
-  };
+//Encoding utility
+const encode = (data: string): string => btoa(unescape(encodeURIComponent(data))); // Example: Base64 encoding
+//Decoding utility
+const decode = (data: string): string => decodeURIComponent(escape(atob(data)));
+
+
+function openIndexedDB(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open('myDatabase', 1);
+
+    request.onupgradeneeded = (event) => {
+      const db = (event.target as IDBOpenDBRequest).result;
+
+      // Create an object store if it doesn't already exist
+      if (!db.objectStoreNames.contains('keyValueStore')) {
+        db.createObjectStore('keyValueStore', { keyPath: 'key' });
+      }
+    };
+
+    request.onsuccess = (event) => {
+      const db = (event.target as IDBOpenDBRequest).result;
+      resolve(db);
+    };
+
+    request.onerror = (event) => {
+      reject(`Error opening IndexedDB: ${(event.target as IDBOpenDBRequest).error}`);
+    };
+  });
 }
 
-// Open the database
-const dbPromise = openDB<MyDB>('my-database', 1, {
-  upgrade(db) {
-    if (!db.objectStoreNames.contains('items')) {
-      db.createObjectStore('items');
-    }
-  },
-});
+export async function saveToIndexedDB(key: string, value: string): Promise<void> {
+  const db = await openIndexedDB();
 
-// Encoding utility
-const encode = (data: string): string => btoa(unescape(encodeURIComponent(data))); // Example: Base64 encoding
-// Decoding utility
-const decode = (data: string): string => decodeURIComponent(escape(atob(data)));
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('keyValueStore', 'readwrite');
+    const store = transaction.objectStore('keyValueStore');
+
+    const encodedValue = encode(value); // Encode the data
+    const request = store.put({ key, value: encodedValue });
+
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject('Failed to save data');
+  });
+}
+
+export async function getFromIndexedDB(key: string): Promise<string | null> {
+  const db = await openIndexedDB();
+
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction('keyValueStore', 'readonly');
+    const store = transaction.objectStore('keyValueStore');
+
+    const request = store.get(key);
+
+    request.onsuccess = (event) => {
+      const result = (event.target as IDBRequest).result;
+      if (result && result.value) {
+        resolve(decode(result.value)); // Decode the data
+      } else {
+        resolve(null);
+      }
+    };
+
+    request.onerror = () => reject('Failed to retrieve data');
+  });
+}
 
-// Save data to IndexedDB
-export const saveToIndexedDB = async (key: string, value: string): Promise<void> => {
-  const db = await dbPromise;
-  const encodedValue = encode(value);
-  await db.put('items', encodedValue, key);
-};
-
-// Get data from IndexedDB
-export const getFromIndexedDB = async (key: string): Promise<string | null> => {
-  const db = await dbPromise;
-  const encodedValue = await db.get('items', key);
-  return encodedValue ? decode(encodedValue) : null;
-};