@ssa-ui-kit/utils 0.0.1-alpha → 1.0.0

package/src/utils/debounce/debounce.spec.ts

@@ -1,85 +1,85 @@
-import { debounce } from '.';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const callNTimes = (fn: any, n: number) => {
-  for (let i = 0; i < n; i++) {
-    fn();
-  }
-};
-
-describe('debounce', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    jest.spyOn(global, 'setTimeout');
-    jest.spyOn(global, 'clearTimeout');
-  });
-
-  afterAll(() => {
-    jest.useRealTimers();
-    jest.restoreAllMocks();
-  });
-
-  it('should cancel immediately without executing', () => {
-    const fn = jest.fn();
-    const [debouncedFn, cancel] = debounce(fn, 100);
-
-    debouncedFn();
-    // Cancel should not execute any pending call
-    cancel();
-    jest.advanceTimersByTime(150);
-    expect(fn).toHaveBeenCalledTimes(0);
-  });
-
-  it('should execute deferred function on the second time, after cancelling for the first time', () => {
-    const fn = jest.fn();
-    const [debouncedFn, cancel] = debounce(fn, 100);
-
-    debouncedFn();
-    // Cancel should not execute any pending call
-    cancel();
-    jest.advanceTimersByTime(150);
-    expect(fn).toHaveBeenCalledTimes(0);
-
-    debouncedFn();
-    jest.advanceTimersByTime(150);
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('delays a function call', () => {
-    const fn = jest.fn();
-    const [debouncedFn, cancel] = debounce(fn, 100);
-
-    // Subsequent calls within the throttle window should be throttled
-    callNTimes(debouncedFn, 3);
-    jest.advanceTimersByTime(50);
-    expect(fn).toHaveBeenCalledTimes(0);
-    jest.advanceTimersByTime(500);
-    expect(fn).toHaveBeenCalledTimes(1);
-
-    // After the throttle window, the next call should execute
-    debouncedFn();
-
-    // Wait for the throttle window to pass
-    jest.advanceTimersByTime(500);
-    expect(fn).toHaveBeenCalledTimes(2);
-
-    // Calling the throttled function after cancel should execute
-    debouncedFn();
-    // ...but cancelled by triggering the cancel function
-    cancel();
-    expect(fn).toHaveBeenCalledTimes(2);
-  });
-
-  it('should debounce and execute the last call within debounce window', () => {
-    const fn = jest.fn();
-    const [debouncedFn] = debounce(fn, 100);
-
-    callNTimes(debouncedFn, 3);
-    jest.advanceTimersByTime(100);
-    expect(fn).toHaveBeenCalledTimes(1);
-
-    debouncedFn();
-    jest.advanceTimersByTime(150);
-    expect(fn).toHaveBeenCalledTimes(2);
-  });
-});
+import { debounce } from '.';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const callNTimes = (fn: any, n: number) => {
+  for (let i = 0; i < n; i++) {
+    fn();
+  }
+};
+
+describe('debounce', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.spyOn(global, 'setTimeout');
+    jest.spyOn(global, 'clearTimeout');
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  it('should cancel immediately without executing', () => {
+    const fn = jest.fn();
+    const [debouncedFn, cancel] = debounce(fn, 100);
+
+    debouncedFn();
+    // Cancel should not execute any pending call
+    cancel();
+    jest.advanceTimersByTime(150);
+    expect(fn).toHaveBeenCalledTimes(0);
+  });
+
+  it('should execute deferred function on the second time, after cancelling for the first time', () => {
+    const fn = jest.fn();
+    const [debouncedFn, cancel] = debounce(fn, 100);
+
+    debouncedFn();
+    // Cancel should not execute any pending call
+    cancel();
+    jest.advanceTimersByTime(150);
+    expect(fn).toHaveBeenCalledTimes(0);
+
+    debouncedFn();
+    jest.advanceTimersByTime(150);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('delays a function call', () => {
+    const fn = jest.fn();
+    const [debouncedFn, cancel] = debounce(fn, 100);
+
+    // Subsequent calls within the throttle window should be throttled
+    callNTimes(debouncedFn, 3);
+    jest.advanceTimersByTime(50);
+    expect(fn).toHaveBeenCalledTimes(0);
+    jest.advanceTimersByTime(500);
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    // After the throttle window, the next call should execute
+    debouncedFn();
+
+    // Wait for the throttle window to pass
+    jest.advanceTimersByTime(500);
+    expect(fn).toHaveBeenCalledTimes(2);
+
+    // Calling the throttled function after cancel should execute
+    debouncedFn();
+    // ...but cancelled by triggering the cancel function
+    cancel();
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should debounce and execute the last call within debounce window', () => {
+    const fn = jest.fn();
+    const [debouncedFn] = debounce(fn, 100);
+
+    callNTimes(debouncedFn, 3);
+    jest.advanceTimersByTime(100);
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    debouncedFn();
+    jest.advanceTimersByTime(150);
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+});

package/src/utils/debounce/debounce.ts

@@ -1,24 +1,24 @@
-type UnknownFn = (...args: any[]) => unknown;
-
-export const debounce = (func: UnknownFn, wait = 200) => {
-  let timeoutId: NodeJS.Timeout | null = null;
-  const executedFunction = (...args: any[]) => {
-    const postponedFn = () => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      func(...args);
-    };
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(postponedFn, wait);
-  };
-
-  const cancel = function () {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  };
-  return [executedFunction, cancel];
-};
+type UnknownFn = (...args: any[]) => unknown;
+
+export const debounce = (func: UnknownFn, wait = 200) => {
+  let timeoutId: NodeJS.Timeout | null = null;
+  const executedFunction = (...args: any[]) => {
+    const postponedFn = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      func(...args);
+    };
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(postponedFn, wait);
+  };
+
+  const cancel = function () {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  };
+  return [executedFunction, cancel];
+};

package/src/utils/debounce/index.ts

@@ -1 +1 @@
-export { debounce } from './debounce';
+export { debounce } from './debounce';

package/src/utils/objects/assocPath.spec.tsx

@@ -1,53 +1,53 @@
-import { assocPath } from '.';
-
-describe('utils => objects => assocPath', () => {
-  it('assocPath should work', () => {
-    const data = {
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    };
-    const result = assocPath(['c', 'name'], 'c')(data);
-    expect(result).toEqual({
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-      c: {
-        name: 'c',
-      },
-    });
-  });
-  it('assocPath should not change source object', () => {
-    const data = {
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    };
-    assocPath(['c', 'name'], 'c')(data);
-    expect(data).toEqual({
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    });
-  });
-});
+import { assocPath } from '.';
+
+describe('utils => objects => assocPath', () => {
+  it('assocPath should work', () => {
+    const data = {
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    };
+    const result = assocPath(['c', 'name'], 'c')(data);
+    expect(result).toEqual({
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+      c: {
+        name: 'c',
+      },
+    });
+  });
+  it('assocPath should not change source object', () => {
+    const data = {
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    };
+    assocPath(['c', 'name'], 'c')(data);
+    expect(data).toEqual({
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    });
+  });
+});

package/src/utils/objects/assocPath.ts

@@ -1,11 +1,11 @@
-export const assocPath =
-  <T>([first, ...rest]: string[], value: any) =>
-  (sourceObject: T): T =>
-    JSON.parse(
-      JSON.stringify({
-        ...sourceObject,
-        [first]: rest.length
-          ? assocPath(rest, value)((sourceObject as any)[first])
-          : value,
-      }),
-    ) as T;
+export const assocPath =
+  <T>([first, ...rest]: string[], value: any) =>
+  (sourceObject: T): T =>
+    JSON.parse(
+      JSON.stringify({
+        ...sourceObject,
+        [first]: rest.length
+          ? assocPath(rest, value)((sourceObject as any)[first])
+          : value,
+      }),
+    ) as T;

package/src/utils/objects/dissocPath.spec.tsx

@@ -1,49 +1,49 @@
-import { dissocPath } from '.';
-
-describe('utils => objects => dissocPath', () => {
-  it('dissocPath should work', () => {
-    const data = {
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    };
-    const result = dissocPath(['a', 'name'])(data);
-    expect(result).toEqual({
-      a: {
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    });
-  });
-  it('dissocPath should not change source object', () => {
-    const data = {
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    };
-    dissocPath(['a', 'name'])(data);
-    expect(data).toEqual({
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    });
-  });
-});
+import { dissocPath } from '.';
+
+describe('utils => objects => dissocPath', () => {
+  it('dissocPath should work', () => {
+    const data = {
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    };
+    const result = dissocPath(['a', 'name'])(data);
+    expect(result).toEqual({
+      a: {
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    });
+  });
+  it('dissocPath should not change source object', () => {
+    const data = {
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    };
+    dissocPath(['a', 'name'])(data);
+    expect(data).toEqual({
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    });
+  });
+});

package/src/utils/objects/dissocPath.ts

@@ -1,14 +1,14 @@
-export const dissocPath =
-  <T>(path: string[]) =>
-  (sourceObject: T): T => {
-    const resultObject = JSON.parse(JSON.stringify(sourceObject));
-
-    path.reduce((acc: any, key, index) => {
-      if (index === path.length - 1) {
-        delete acc[key];
-      }
-      return acc[key];
-    }, resultObject);
-
-    return resultObject;
-  };
+export const dissocPath =
+  <T>(path: string[]) =>
+  (sourceObject: T): T => {
+    const resultObject = JSON.parse(JSON.stringify(sourceObject));
+
+    path.reduce((acc: any, key, index) => {
+      if (index === path.length - 1) {
+        delete acc[key];
+      }
+      return acc[key];
+    }, resultObject);
+
+    return resultObject;
+  };

package/src/utils/objects/index.ts

@@ -1,7 +1,7 @@
-export * from './mapObjIndexed';
-export * from './assocPath';
-export * from './dissocPath';
-export * from './path';
-export * from './pathOr';
-export * from './prop';
-export * from './propOr';
+export * from './mapObjIndexed';
+export * from './assocPath';
+export * from './dissocPath';
+export * from './path';
+export * from './pathOr';
+export * from './prop';
+export * from './propOr';

package/src/utils/objects/mapObjIndexed.spec.tsx

@@ -1,33 +1,33 @@
-import { mapObjIndexed } from '.';
-
-describe('utils => objects => mapObjIndexed', () => {
-  it('mapObjIndexed should work', () => {
-    const data = {
-      a: {
-        name: 'a',
-        value: 1,
-      },
-      b: {
-        name: 'b',
-        value: 2,
-      },
-    };
-    const result = mapObjIndexed(
-      (item, key) => ({
-        name: key,
-        value: item.value + key,
-      }),
-      data,
-    );
-    expect(result).toEqual({
-      a: {
-        name: 'a',
-        value: '1a',
-      },
-      b: {
-        name: 'b',
-        value: '2b',
-      },
-    });
-  });
-});
+import { mapObjIndexed } from '.';
+
+describe('utils => objects => mapObjIndexed', () => {
+  it('mapObjIndexed should work', () => {
+    const data = {
+      a: {
+        name: 'a',
+        value: 1,
+      },
+      b: {
+        name: 'b',
+        value: 2,
+      },
+    };
+    const result = mapObjIndexed(
+      (item, key) => ({
+        name: key,
+        value: item.value + key,
+      }),
+      data,
+    );
+    expect(result).toEqual({
+      a: {
+        name: 'a',
+        value: '1a',
+      },
+      b: {
+        name: 'b',
+        value: '2b',
+      },
+    });
+  });
+});

package/src/utils/objects/mapObjIndexed.ts

@@ -1,15 +1,15 @@
-type MapObjIndexedFn<T, U> = (
-  value: T,
-  key: string,
-  obj: Record<string, T>,
-) => U;
-
-export const mapObjIndexed = <T, U>(
-  fn: MapObjIndexedFn<T, U>,
-  obj: Record<string, T>,
-): Record<string, U> => {
-  return Object.keys(obj).reduce((result: Record<string, U>, key: string) => {
-    result[key] = fn(obj[key], key, obj);
-    return result;
-  }, {});
-};
+type MapObjIndexedFn<T, U> = (
+  value: T,
+  key: string,
+  obj: Record<string, T>,
+) => U;
+
+export const mapObjIndexed = <T, U>(
+  fn: MapObjIndexedFn<T, U>,
+  obj: Record<string, T>,
+): Record<string, U> => {
+  return Object.keys(obj).reduce((result: Record<string, U>, key: string) => {
+    result[key] = fn(obj[key], key, obj);
+    return result;
+  }, {});
+};

package/src/utils/objects/path.spec.tsx

@@ -1,24 +1,24 @@
-import { path } from '.';
-
-describe('utils => objects => path', () => {
-  const data = {
-    a: {
-      name: 'a',
-      value: 1,
-    },
-    b: {
-      name: 'b',
-      value: 2,
-    },
-  };
-
-  it('path should work with correct path', () => {
-    const result = path(['a', 'name'])(data);
-    expect(result).toEqual('a');
-  });
-
-  it('path should work with incorrect path', () => {
-    const result = path(['a', 'name', 'value'])(data);
-    expect(result).toEqual(undefined);
-  });
-});
+import { path } from '.';
+
+describe('utils => objects => path', () => {
+  const data = {
+    a: {
+      name: 'a',
+      value: 1,
+    },
+    b: {
+      name: 'b',
+      value: 2,
+    },
+  };
+
+  it('path should work with correct path', () => {
+    const result = path(['a', 'name'])(data);
+    expect(result).toEqual('a');
+  });
+
+  it('path should work with incorrect path', () => {
+    const result = path(['a', 'name', 'value'])(data);
+    expect(result).toEqual(undefined);
+  });
+});

package/src/utils/objects/path.ts

@@ -1,4 +1,4 @@
-export const path =
-  <T extends Record<string | number, any>, R>(path: string[]) =>
-  (obj: T): unknown =>
-    path.reduce((prev, curr: string | number) => prev?.[curr], obj);
+export const path =
+  <T extends Record<string | number, any>, R>(path: Array<string | number>) =>
+  (obj: T): unknown =>
+    path.reduce((prev, curr: string | number) => prev?.[curr], obj);