pixel-react 1.6.6 → 1.6.8

package/src/utils/capitalize/capitalize.tsx

@@ -1,4 +1,4 @@
-export const capitalize = (text: string): string => {
-  if (!text) return '';
-  return text.charAt(0).toUpperCase() + text.slice(1);
-};
+export const capitalize = (text: string): string => {
+  if (!text) return '';
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};

package/src/utils/checkDuplicates/CheckDuplicates.stories.tsx

@@ -1,40 +1,40 @@
-import React from 'react';
-import { Meta, StoryObj } from '@storybook/react';
-import { hasDuplicateFile } from './checkDuplicates';
-
-export default {
-  title: 'Utils/HasDuplicateFile',
-  argTypes: {
-    array: {
-      control: 'object',
-      description: 'Array of objects to check for duplicates.',
-    },
-    property: {
-      control: 'text',
-      description: 'Optional property to check for duplicates.',
-    },
-  },
-} satisfies Meta;
-
-export const Default: StoryObj = {
-  args: {
-    array: [
-      { id: 1, name: 'file1' },
-      { id: 2, name: 'file2' },
-      { id: 1, name: 'file1' },
-    ],
-    property: 'id',
-  },
-  render: (args) => {
-    const result = hasDuplicateFile(args.array, args.property);
-    return (
-      <div>
-        <h3>
-          Duplicate Check Result:{' '}
-          {result ? 'Duplicates Found' : 'No Duplicates'}
-        </h3>
-        <pre>{JSON.stringify(args.array, null, 2)}</pre>
-      </div>
-    );
-  },
-};
+import React from 'react';
+import { Meta, StoryObj } from '@storybook/react';
+import { hasDuplicateFile } from './checkDuplicates';
+
+export default {
+  title: 'Utils/HasDuplicateFile',
+  argTypes: {
+    array: {
+      control: 'object',
+      description: 'Array of objects to check for duplicates.',
+    },
+    property: {
+      control: 'text',
+      description: 'Optional property to check for duplicates.',
+    },
+  },
+} satisfies Meta;
+
+export const Default: StoryObj = {
+  args: {
+    array: [
+      { id: 1, name: 'file1' },
+      { id: 2, name: 'file2' },
+      { id: 1, name: 'file1' },
+    ],
+    property: 'id',
+  },
+  render: (args) => {
+    const result = hasDuplicateFile(args.array, args.property);
+    return (
+      <div>
+        <h3>
+          Duplicate Check Result:{' '}
+          {result ? 'Duplicates Found' : 'No Duplicates'}
+        </h3>
+        <pre>{JSON.stringify(args.array, null, 2)}</pre>
+      </div>
+    );
+  },
+};

package/src/utils/checkDuplicates/checkDuplicates.ts

@@ -1,13 +1,13 @@
-// Will be used to find duplicate key-value pair in an array of objects.
-
-export const hasDuplicateFile = (array: any[], property: string): boolean => {
-  const seen = new Set();
-  for (const obj of array) {
-    const key = property ? obj[property] : JSON.stringify(obj);
-    if (seen.has(key)) {
-      return true;
-    }
-    seen.add(key);
-  }
-  return false;
-};
+// Will be used to find duplicate key-value pair in an array of objects.
+
+export const hasDuplicateFile = (array: any[], property: string): boolean => {
+  const seen = new Set();
+  for (const obj of array) {
+    const key = property ? obj[property] : JSON.stringify(obj);
+    if (seen.has(key)) {
+      return true;
+    }
+    seen.add(key);
+  }
+  return false;
+};

package/src/utils/checkEmpty/checkEmpty.stories.tsx

@@ -1,34 +1,34 @@
-import { checkEmpty } from './checkEmpty';
-
-export default {
-  title: 'Utils/checkEmpty',
-  component: checkEmpty,
-};
-
-export const Default = () => {
-  const testCases = [
-    { value: null, expected: true },
-    { value: undefined, expected: true },
-    { value: '', expected: true },
-    { value: [], expected: true },
-    { value: {}, expected: true },
-    { value: 0, expected: true },
-    { value: 'Hello', expected: false },
-    { value: [1, 2, 3], expected: false },
-    { value: { key: 'value' }, expected: false },
-  ];
-
-  return (
-    <div>
-      <h1>
-        <u>checkEmpty(value)</u> - true / false
-      </h1>
-      {testCases.map((test, index) => (
-        <div key={index}>
-          checkEmpty( {JSON.stringify(test.value)} ) -
-          {checkEmpty(test.value) ? 'True' : 'False'}
-        </div>
-      ))}
-    </div>
-  );
-};
+import { checkEmpty } from './checkEmpty';
+
+export default {
+  title: 'Utils/checkEmpty',
+  component: checkEmpty,
+};
+
+export const Default = () => {
+  const testCases = [
+    { value: null, expected: true },
+    { value: undefined, expected: true },
+    { value: '', expected: true },
+    { value: [], expected: true },
+    { value: {}, expected: true },
+    { value: 0, expected: true },
+    { value: 'Hello', expected: false },
+    { value: [1, 2, 3], expected: false },
+    { value: { key: 'value' }, expected: false },
+  ];
+
+  return (
+    <div>
+      <h1>
+        <u>checkEmpty(value)</u> - true / false
+      </h1>
+      {testCases.map((test, index) => (
+        <div key={index}>
+          checkEmpty( {JSON.stringify(test.value)} ) -
+          {checkEmpty(test.value) ? 'True' : 'False'}
+        </div>
+      ))}
+    </div>
+  );
+};

package/src/utils/checkEmpty/checkEmpty.ts

@@ -1,24 +1,24 @@
-type valueType = any;
-
-export const checkEmpty = (value: valueType): boolean => {
-  // Check for null or undefined
-  if (value == null) return true;
-
-  // Check for strings
-  if (typeof value === 'string') return value.trim().length === 0;
-
-  // Check for arrays
-  if (Array.isArray(value)) return value.length === 0;
-
-  // Check for objects
-  if (typeof value === 'object') {
-    // Handle Map and Set
-    if (value instanceof Map || value instanceof Set) return value.size === 0;
-
-    // Handle regular objects
-    return Object.keys(value).length === 0;
-  }
-
-  // For all other types (numbers, booleans, etc.), return false as they are not "empty"
-  return false;
-};
+type valueType = any;
+
+export const checkEmpty = (value: valueType): boolean => {
+  // Check for null or undefined
+  if (value == null) return true;
+
+  // Check for strings
+  if (typeof value === 'string') return value.trim().length === 0;
+
+  // Check for arrays
+  if (Array.isArray(value)) return value.length === 0;
+
+  // Check for objects
+  if (typeof value === 'object') {
+    // Handle Map and Set
+    if (value instanceof Map || value instanceof Set) return value.size === 0;
+
+    // Handle regular objects
+    return Object.keys(value).length === 0;
+  }
+
+  // For all other types (numbers, booleans, etc.), return false as they are not "empty"
+  return false;
+};

package/src/utils/compareArrays/compareArrays.stories.tsx

@@ -1,62 +1,62 @@
-import { compareArrays } from './compareArrays'; // Adjust the import path as necessary
-
-export default {
-  title: 'Utils/compareArrays',
-  component: compareArrays,
-};
-
-export const Default = () => {
-  const testCases = [
-    { arr1: [1, 2, 3], arr2: [1, 2, 3], expected: true },
-    { arr1: [1, 2, 3], arr2: [1, 2, 4], expected: false },
-    { arr1: [1, { a: 1 }], arr2: [1, { a: 1 }], expected: true },
-    { arr1: [1, { a: 1 }], arr2: [1, { a: 2 }], expected: false },
-    { arr1: [1, 2, 3], arr2: [1, 2, 3, 4], expected: false },
-    { arr1: [], arr2: [], expected: true },
-    { arr1: [null, undefined], arr2: [null, undefined], expected: true },
-    { arr1: [null], arr2: [undefined], expected: false },
-    {
-      arr1: [
-        [1, 2],
-        [3, 4],
-      ],
-      arr2: [
-        [1, 2],
-        [3, 4],
-      ],
-      expected: true,
-    },
-    {
-      arr1: [
-        [1, 2],
-        [3, 4],
-      ],
-      arr2: [
-        [1, 2],
-        [4, 3],
-      ],
-      expected: false,
-    },
-  ];
-
-  return (
-    <div>
-      <h1>
-        <u>compareArrays(arr1, arr2)</u> - Expected / Actual
-      </h1>
-      {testCases.map(({ arr1, arr2, expected }, index) => {
-        const actual = compareArrays(arr1, arr2);
-        return (
-          <div key={index}>
-            <strong>
-              compareArrays({JSON.stringify(arr1)}, {JSON.stringify(arr2)}) -
-            </strong>
-            <span style={{ color: actual === expected ? 'green' : 'red' }}>
-              {` Expected: ${expected}, Actual: ${actual}`}
-            </span>
-          </div>
-        );
-      })}
-    </div>
-  );
-};
+import { compareArrays } from './compareArrays'; // Adjust the import path as necessary
+
+export default {
+  title: 'Utils/compareArrays',
+  component: compareArrays,
+};
+
+export const Default = () => {
+  const testCases = [
+    { arr1: [1, 2, 3], arr2: [1, 2, 3], expected: true },
+    { arr1: [1, 2, 3], arr2: [1, 2, 4], expected: false },
+    { arr1: [1, { a: 1 }], arr2: [1, { a: 1 }], expected: true },
+    { arr1: [1, { a: 1 }], arr2: [1, { a: 2 }], expected: false },
+    { arr1: [1, 2, 3], arr2: [1, 2, 3, 4], expected: false },
+    { arr1: [], arr2: [], expected: true },
+    { arr1: [null, undefined], arr2: [null, undefined], expected: true },
+    { arr1: [null], arr2: [undefined], expected: false },
+    {
+      arr1: [
+        [1, 2],
+        [3, 4],
+      ],
+      arr2: [
+        [1, 2],
+        [3, 4],
+      ],
+      expected: true,
+    },
+    {
+      arr1: [
+        [1, 2],
+        [3, 4],
+      ],
+      arr2: [
+        [1, 2],
+        [4, 3],
+      ],
+      expected: false,
+    },
+  ];
+
+  return (
+    <div>
+      <h1>
+        <u>compareArrays(arr1, arr2)</u> - Expected / Actual
+      </h1>
+      {testCases.map(({ arr1, arr2, expected }, index) => {
+        const actual = compareArrays(arr1, arr2);
+        return (
+          <div key={index}>
+            <strong>
+              compareArrays({JSON.stringify(arr1)}, {JSON.stringify(arr2)}) -
+            </strong>
+            <span style={{ color: actual === expected ? 'green' : 'red' }}>
+              {` Expected: ${expected}, Actual: ${actual}`}
+            </span>
+          </div>
+        );
+      })}
+    </div>
+  );
+};

package/src/utils/compareArrays/compareArrays.ts

@@ -1,31 +1,31 @@
-import { compareObjects } from '../compareObjects/compareObjects';
-
-// Define a type for any object
-export type AnyObject = Record<string, unknown>;
-
-/**
- * Compare two arrays for equality.
- * This function checks if both arrays contain the same elements in the same order,
- * including nested structures.
- *
- * @param arr1 - The first array to compare.
- * @param arr2 - The second array to compare.
- * @returns - A boolean indicating if the arrays are equal.
- */
-export const compareArrays = (arr1: unknown[], arr2: unknown[]): boolean => {
-  // Check if both are arrays
-  if (!Array.isArray(arr1) || !Array.isArray(arr2)) return false;
-
-  // Check if lengths are different
-  if (arr1.length !== arr2.length) return false;
-
-  // Compare each element
-  return arr1.every((element, index) => {
-    const otherElement = arr2[index];
-    // Recursively compare objects or arrays, or check for strict equality
-    return compareObjects(
-      element as AnyObject | null,
-      otherElement as AnyObject | null
-    );
-  });
-};
+import { compareObjects } from '../compareObjects/compareObjects';
+
+// Define a type for any object
+export type AnyObject = Record<string, unknown>;
+
+/**
+ * Compare two arrays for equality.
+ * This function checks if both arrays contain the same elements in the same order,
+ * including nested structures.
+ *
+ * @param arr1 - The first array to compare.
+ * @param arr2 - The second array to compare.
+ * @returns - A boolean indicating if the arrays are equal.
+ */
+export const compareArrays = (arr1: unknown[], arr2: unknown[]): boolean => {
+  // Check if both are arrays
+  if (!Array.isArray(arr1) || !Array.isArray(arr2)) return false;
+
+  // Check if lengths are different
+  if (arr1.length !== arr2.length) return false;
+
+  // Compare each element
+  return arr1.every((element, index) => {
+    const otherElement = arr2[index];
+    // Recursively compare objects or arrays, or check for strict equality
+    return compareObjects(
+      element as AnyObject | null,
+      otherElement as AnyObject | null
+    );
+  });
+};

package/src/utils/compareObjects/compareObjects.stories.tsx

@@ -1,51 +1,51 @@
-import { compareObjects } from './compareObjects'; // Adjust the import path as necessary
-
-export default {
-  title: 'Utils/compareObjects',
-  component: compareObjects,
-};
-
-export const Default = () => {
-  const testCases = [
-    {
-      obj1: { a: 1, b: [2, { c: 3 }] },
-      obj2: { a: 1, b: [2, { c: 3 }] },
-      expected: true,
-    },
-    {
-      obj1: { a: 1, b: [2, { c: 3 }] },
-      obj2: { a: 1, b: [3, 2] },
-      expected: false,
-    },
-    {
-      obj1: { a: 1, b: { c: 2 } },
-      obj2: { a: 1, b: { c: 2 } },
-      expected: true,
-    },
-    {
-      obj1: { a: 1, b: { c: 2 } },
-      obj2: { a: 1, b: { c: 3 } },
-      expected: false,
-    },
-    { obj1: null, obj2: null, expected: true },
-    { obj1: { a: null }, obj2: { a: null }, expected: true },
-    { obj1: { a: 1 }, obj2: { a: null }, expected: false },
-    { obj1: {}, obj2: {}, expected: true },
-    { obj1: { a: 0 }, obj2: { a: 0 }, expected: true },
-    { obj1: { a: 0 }, obj2: { a: 1 }, expected: false },
-  ];
-
-  return (
-    <div>
-      <h1>
-        <u>compareObjects(obj1, obj2)</u> - true / false
-      </h1>
-      {testCases.map(({ obj1, obj2, expected }, index) => (
-        <div key={index}>
-          compareObjects({JSON.stringify(obj1)}, {JSON.stringify(obj2)}) -
-          {compareObjects(obj1, obj2) === expected ? ' True' : ' False'}
-        </div>
-      ))}
-    </div>
-  );
-};
+import { compareObjects } from './compareObjects'; // Adjust the import path as necessary
+
+export default {
+  title: 'Utils/compareObjects',
+  component: compareObjects,
+};
+
+export const Default = () => {
+  const testCases = [
+    {
+      obj1: { a: 1, b: [2, { c: 3 }] },
+      obj2: { a: 1, b: [2, { c: 3 }] },
+      expected: true,
+    },
+    {
+      obj1: { a: 1, b: [2, { c: 3 }] },
+      obj2: { a: 1, b: [3, 2] },
+      expected: false,
+    },
+    {
+      obj1: { a: 1, b: { c: 2 } },
+      obj2: { a: 1, b: { c: 2 } },
+      expected: true,
+    },
+    {
+      obj1: { a: 1, b: { c: 2 } },
+      obj2: { a: 1, b: { c: 3 } },
+      expected: false,
+    },
+    { obj1: null, obj2: null, expected: true },
+    { obj1: { a: null }, obj2: { a: null }, expected: true },
+    { obj1: { a: 1 }, obj2: { a: null }, expected: false },
+    { obj1: {}, obj2: {}, expected: true },
+    { obj1: { a: 0 }, obj2: { a: 0 }, expected: true },
+    { obj1: { a: 0 }, obj2: { a: 1 }, expected: false },
+  ];
+
+  return (
+    <div>
+      <h1>
+        <u>compareObjects(obj1, obj2)</u> - true / false
+      </h1>
+      {testCases.map(({ obj1, obj2, expected }, index) => (
+        <div key={index}>
+          compareObjects({JSON.stringify(obj1)}, {JSON.stringify(obj2)}) -
+          {compareObjects(obj1, obj2) === expected ? ' True' : ' False'}
+        </div>
+      ))}
+    </div>
+  );
+};

package/src/utils/compareObjects/compareObjects.ts

@@ -1,53 +1,53 @@
-// Define a type for any object
-export type AnyObject = Record<string, unknown>;
-
-export const compareObjects = (
-  obj1: AnyObject | null,
-  obj2: AnyObject | null
-): boolean => {
-  // Check if both are strictly equal (handles primitive types and same reference)
-  if (obj1 === obj2) return true;
-
-  // Check if either is null or not an object
-  if (
-    obj1 == null ||
-    obj2 == null ||
-    typeof obj1 !== 'object' ||
-    typeof obj2 !== 'object'
-  ) {
-    return false;
-  }
-
-  // Handle array comparison
-  const isArray1 = Array.isArray(obj1);
-  const isArray2 = Array.isArray(obj2);
-  if (isArray1 !== isArray2) return false; // One is an array, the other is not
-
-  // Create arrays of keys for both objects
-  const keys1 = isArray1 ? obj1 : Object.keys(obj1);
-  const keys2 = isArray2 ? obj2 : Object.keys(obj2);
-
-  // Check if the number of keys is different
-  if (keys1.length !== keys2.length) return false;
-
-  // Create a Set for keys2 for O(1) lookups (only for objects)
-  if (!isArray1) {
-    const keysSet2 = new Set<string>(keys2 as string[]);
-
-    // Check each key and value
-    return keys1.every((key) => {
-      return (
-        keysSet2.has(key) &&
-        compareObjects(
-          obj1[key] as AnyObject | null,
-          obj2[key] as AnyObject | null
-        )
-      );
-    });
-  } else {
-    // If arrays, compare elements directly
-    return keys1.every((item, index) =>
-      compareObjects(item as AnyObject | null, keys2[index] as AnyObject | null)
-    );
-  }
-};
+// Define a type for any object
+export type AnyObject = Record<string, unknown>;
+
+export const compareObjects = (
+  obj1: AnyObject | null,
+  obj2: AnyObject | null
+): boolean => {
+  // Check if both are strictly equal (handles primitive types and same reference)
+  if (obj1 === obj2) return true;
+
+  // Check if either is null or not an object
+  if (
+    obj1 == null ||
+    obj2 == null ||
+    typeof obj1 !== 'object' ||
+    typeof obj2 !== 'object'
+  ) {
+    return false;
+  }
+
+  // Handle array comparison
+  const isArray1 = Array.isArray(obj1);
+  const isArray2 = Array.isArray(obj2);
+  if (isArray1 !== isArray2) return false; // One is an array, the other is not
+
+  // Create arrays of keys for both objects
+  const keys1 = isArray1 ? obj1 : Object.keys(obj1);
+  const keys2 = isArray2 ? obj2 : Object.keys(obj2);
+
+  // Check if the number of keys is different
+  if (keys1.length !== keys2.length) return false;
+
+  // Create a Set for keys2 for O(1) lookups (only for objects)
+  if (!isArray1) {
+    const keysSet2 = new Set<string>(keys2 as string[]);
+
+    // Check each key and value
+    return keys1.every((key) => {
+      return (
+        keysSet2.has(key) &&
+        compareObjects(
+          obj1[key] as AnyObject | null,
+          obj2[key] as AnyObject | null
+        )
+      );
+    });
+  } else {
+    // If arrays, compare elements directly
+    return keys1.every((item, index) =>
+      compareObjects(item as AnyObject | null, keys2[index] as AnyObject | null)
+    );
+  }
+};