pixel-react 1.0.1 → 1.0.3

package/src/utils/debounce/debounce.ts

@@ -0,0 +1,28 @@
+type Callback = (...args: any[]) => void;
+
+// Export the DebouncedFunction interface to make it publicly accessible
+export interface DebouncedFunction extends Function {
+  cancel: () => void;
+}
+
+export const debounce = (func: Callback, delay: number): DebouncedFunction => {
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+  const debounced: DebouncedFunction = function (this: any, ...args: any[]) {
+    // Clear the previous timeout if it exists
+    if (timeoutId) clearTimeout(timeoutId);
+
+    // Set a new timeout
+    timeoutId = setTimeout(() => {
+      func.apply(this, args);
+    }, delay);
+  };
+
+  // Method to cancel the debounced function
+  debounced.cancel = () => {
+    if (timeoutId) clearTimeout(timeoutId);
+    timeoutId = null;
+  };
+
+  return debounced;
+};

package/src/utils/find/findAndInsert.stories.tsx

@@ -0,0 +1,119 @@
+// findAndInsert.stories.tsx
+import { useState } from 'react';
+import { findAndInsert, AnyObject } from './findAndInsert';
+
+export default {
+  title: 'Utils/findAndInsert',
+  component: findAndInsert,
+};
+
+const initialData: AnyObject[] = [
+  { id: 1, name: 'Object 1' },
+  {
+    id: 2,
+    name: 'Object 2',
+    children: [
+      { id: 3, name: 'Child 1', children: [{ id: 5, name: 'SubChild 1' }] },
+      { id: 4, name: 'Child 2' },
+    ],
+  },
+];
+
+export const InteractivePlayground = () => {
+  const [data, setData] = useState<AnyObject[]>(initialData);
+  const [selectedId, setSelectedId] = useState<number | null>(null);
+  const [newEntryName, setNewEntryName] = useState<string>('New Object');
+  const [insertPosition, setInsertPosition] = useState<
+    'above' | 'below' | 'replace'
+  >('below');
+
+  const handleInsert = () => {
+    if (selectedId !== null) {
+      const newEntry = { id: Date.now(), name: newEntryName };
+      const result = findAndInsert(
+        data,
+        'id',
+        selectedId,
+        newEntry,
+        insertPosition,
+        'children'
+      );
+      if (result) {
+        setData(result.updatedArray);
+      } else {
+        alert('Item not found in nested structure');
+      }
+    }
+  };
+
+  const generateOptions = (
+    data: AnyObject[],
+    prefix = ''
+  ): { id: number; label: string }[] => {
+    const options: { id: number; label: string }[] = [];
+    function recurse(items: AnyObject[], levelPrefix: string) {
+      items.forEach((item) => {
+        options.push({
+          id: item.id,
+          label: `${levelPrefix}${item.name} (ID: ${item.id})`,
+        });
+        if (item.children) recurse(item.children, `${levelPrefix}- `);
+      });
+    }
+    recurse(data, prefix);
+    return options;
+  };
+
+  const options = generateOptions(data);
+
+  return (
+    <div>
+      <h1>Interactive Playground for findAndInsert</h1>
+      <label htmlFor="targetId">Select Object:</label>
+      <select
+        id="targetId"
+        onChange={(e) => setSelectedId(Number(e.target.value))}
+        value={selectedId !== null ? selectedId : ''}
+      >
+        <option value="" disabled>
+          Select an object
+        </option>
+        {options.map((option) => (
+          <option key={option.id} value={option.id}>
+            {option.label}
+          </option>
+        ))}
+      </select>
+
+      <div>
+        <label htmlFor="newEntryName">New Entry Name:</label>
+        <input
+          type="text"
+          id="newEntryName"
+          value={newEntryName}
+          onChange={(e) => setNewEntryName(e.target.value)}
+        />
+      </div>
+
+      <div>
+        <label htmlFor="insertPosition">Insert Position:</label>
+        <select
+          id="insertPosition"
+          value={insertPosition}
+          onChange={(e) =>
+            setInsertPosition(e.target.value as 'above' | 'below' | 'replace')
+          }
+        >
+          <option value="above">Above</option>
+          <option value="below">Below</option>
+          <option value="replace">Replace</option>
+        </select>
+      </div>
+
+      <button onClick={handleInsert}>Insert Entry</button>
+
+      <h2>Current Data:</h2>
+      <pre>{JSON.stringify(data, null, 2)}</pre>
+    </div>
+  );
+};

package/src/utils/find/findAndInsert.ts

@@ -0,0 +1,49 @@
+// findAndInsert.ts
+export type AnyObject = { id: number; [key: string]: any };
+
+export function findAndInsert<T extends AnyObject>(
+  data: T[],
+  key: keyof T,
+  targetId: number,
+  newEntry: T,
+  insertPosition: 'above' | 'below' | 'replace',
+  childrenKey: string = 'children' // Allow dynamic key for nested children
+): { updatedArray: T[] } | null {
+  function recursiveSearch(items: T[]): { updatedArray: T[] } | null {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+
+      // Check if the item matches the target id
+      if (item && item[key] === targetId) {
+        const updatedItems = [...items];
+
+        if (insertPosition === 'replace') {
+          updatedItems[i] = newEntry; // Replace the current item
+        } else {
+          // Insert above or below
+          updatedItems.splice(
+            insertPosition === 'above' ? i : i + 1,
+            0,
+            newEntry
+          );
+        }
+
+        return { updatedArray: updatedItems };
+      }
+
+      // Dynamically check nested children using the `childrenKey`
+      if (item && item[childrenKey] && Array.isArray(item[childrenKey])) {
+        const result = recursiveSearch(item[childrenKey] as T[]);
+        if (result) {
+          return {
+            updatedArray: items.map((x, idx) =>
+              idx === i ? { ...x, [childrenKey]: result.updatedArray } : x
+            ),
+          };
+        }
+      }
+    }
+    return null;
+  }
+  return recursiveSearch(data);
+}

package/src/utils/throttle/throttle.stories.tsx

@@ -0,0 +1,100 @@
+import { throttle } from './throttle'; // Adjust the import path as necessary
+
+export default {
+  title: 'Utils/throttle',
+  component: throttle,
+};
+
+export const Default = () => {
+  const testCases = [
+    {
+      description: 'Basic function call',
+      expectedOutput: 'Function called! (at most once every 300ms)',
+      limit: 300,
+      setup: () => {
+        const throttledFunc = throttle(
+          () => console.log('Function called!'),
+          300
+        );
+        for (let i = 0; i < 5; i++) {
+          throttledFunc(); // Call the throttled function multiple times
+        }
+      },
+      code: `const throttledFunc = throttle(() => console.log('Function called!'), 300);\nfor (let i = 0; i < 5; i++) {\n  throttledFunc();\n}`,
+    },
+    {
+      description: 'Throttling with rapid calls',
+      expectedOutput: 'Function called! (at most once every 500ms)',
+      limit: 500,
+      setup: () => {
+        const throttledFunc = throttle(
+          () => console.log('Throttled call!'),
+          500
+        );
+        for (let i = 0; i < 10; i++) {
+          throttledFunc(); // Call the throttled function rapidly
+        }
+      },
+      code: `const throttledFunc = throttle(() => console.log('Throttled call!'), 500);\nfor (let i = 0; i < 10; i++) {\n  throttledFunc();\n}`,
+    },
+    {
+      description: 'Cancel throttled function',
+      expectedOutput: 'Function should not be called if canceled',
+      limit: 200,
+      setup: () => {
+        const throttledFunc = throttle(
+          () => console.log('Should not be called!'),
+          200
+        );
+        throttledFunc(); // Call the throttled function
+        throttledFunc.cancel(); // Cancel the function
+      },
+      code: `const throttledFunc = throttle(() => console.log('Should not be called!'), 200);\nthrottledFunc();\nthrottledFunc.cancel();`,
+    },
+    {
+      description: 'Scroll event handling',
+      expectedOutput: 'Scroll event handled (at most once every 400ms)',
+      limit: 400,
+      setup: () => {
+        const throttledScroll = throttle(
+          () => console.log('Scroll event handled'),
+          400
+        );
+
+        // Simulating rapid scroll events
+        for (let i = 0; i < 10; i++) {
+          throttledScroll(); // Simulate scroll event
+        }
+      },
+      code: `const throttledScroll = throttle(() => console.log('Scroll event handled'), 400);\nfor (let i = 0; i < 10; i++) {\n  throttledScroll();\n}`,
+    },
+  ];
+
+  return (
+    <div>
+      <h1>
+        <u>throttle(function, limit)</u> - Demonstrating throttle functionality
+      </h1>
+      {testCases.map(
+        ({ description, expectedOutput, limit, setup, code }, index) => (
+          <div key={index}>
+            <h3>{description}</h3>
+            <button
+              onClick={() => {
+                setup(); // Run the setup for the test case
+                setTimeout(() => {
+                  console.log(expectedOutput);
+                }, limit + 100); // Wait a bit longer than the limit to check output
+              }}
+            >
+              Run Test
+            </button>
+            <pre>
+              <code>{code}</code>
+            </pre>
+          </div>
+        )
+      )}
+    </div>
+  );
+};

package/src/utils/throttle/throttle.ts

@@ -0,0 +1,33 @@
+type Callback = (...args: any[]) => void;
+
+export interface ThrottledFunction extends Function {
+  cancel: () => void;
+}
+
+export const throttle = (func: Callback, limit: number): ThrottledFunction => {
+  let lastFunc: ReturnType<typeof setTimeout> | null;
+  let lastRan: number | null = null;
+
+  const throttled: ThrottledFunction = function (this: any, ...args: any[]) {
+    const context = this;
+    if (lastRan === null || Date.now() - lastRan >= limit) {
+      func.apply(context, args);
+      lastRan = Date.now();
+    } else {
+      if (lastFunc) clearTimeout(lastFunc);
+      lastFunc = setTimeout(() => {
+        func.apply(context, args);
+        lastRan = Date.now();
+      }, limit - (Date.now() - lastRan));
+    }
+  };
+
+  // Method to cancel the throttled function
+  throttled.cancel = () => {
+    if (lastFunc) clearTimeout(lastFunc);
+    lastFunc = null;
+    lastRan = null;
+  };
+
+  return throttled;
+};

package/vite.config.js

@@ -11,20 +11,12 @@ export default {
       },
     }),
   ],
-
-  // resolve: {
-  //   alias: {
-  //     '@components': path.resolve(__dirname, './src/components'),
-  //     '@styles': path.resolve(__dirname, './src/assets/styles'),
-  //     '@icons': path.resolve(__dirname, './src/assets/icons'),
-  //   },
-  // },
-
-  // css: {
-  //   preprocessorOptions: {
-  //     scss: {
-  //       additionalData: `@import "./src/assets/styles/_colors.scss";`,
-  //     },
-  //   },
-  // },
+  css: {
+    preprocessorOptions: {
+      scss: {
+        // This option tells Vite to use Dart Sass for SCSS processing
+        implementation: require('sass'),
+      },
+    },
+  },
 };