playbook_ui 14.16.0.pre.alpha.PLAY1938completetooltipfloatinguitransition6830 → 14.16.0.pre.alpha.play1756pbcontenttag6933

data/app/pb_kits/playbook/utilities/object.test.js

@@ -1,4 +1,4 @@
-import { isEmpty, get, isString, uniqueId, omitBy, noop, merge, filter, find, partial } from './object';
+import { isEmpty, get, isString, uniqueId, omitBy, noop, merge, filter, find, partial, map, cloneDeep, omit, debounce } from './object';
 
 describe('Lodash functions', () => {
   describe('isEmpty', () => {
@@ -234,4 +234,152 @@ describe('Lodash functions', () => {
       expect(joinPartial('b', 'c')).toBe('a_b_c');
     });
   });
+
+  describe('map', () => {
+    test('maps over an array with a function iteratee', () => {
+      const arr = [1, 2, 3];
+      const result = map(arr, (num) => num * 2);
+      expect(result).toEqual([2, 4, 6]);
+    });
+
+    test('maps over an array with a string iteratee', () => {
+      const arr = [{ value: 1 }, { value: 2 }, { value: 3 }];
+      const result = map(arr, 'value');
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    test('maps over an object with a function iteratee', () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      const result = map(obj, (val, key) => key + val);
+      expect(result.sort()).toEqual(['a1', 'b2', 'c3'].sort());
+    });
+
+    test('maps over an object with a string iteratee', () => {
+      const obj = {
+        one: { num: 1 },
+        two: { num: 2 },
+        three: { num: 3 },
+      };
+      const result = map(obj, 'num');
+      expect(result.sort()).toEqual([1, 2, 3].sort());
+    });
+
+    test('returns original values if no iteratee provided', () => {
+      const arr = [1, 2, 3];
+      const result = map(arr);
+      expect(result).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('cloneDeep', () => {
+    test('clones primitive values', () => {
+      expect(cloneDeep(42)).toBe(42);
+      expect(cloneDeep('test')).toBe('test');
+      expect(cloneDeep(null)).toBe(null);
+    });
+
+    test('clones arrays deeply', () => {
+      const arr = [1, [2, 3]];
+      const cloned = cloneDeep(arr);
+      expect(cloned).toEqual(arr);
+      cloned[1][0] = 99;
+      expect(arr[1][0]).toBe(2);
+    });
+
+    test('clones objects deeply', () => {
+      const obj = { a: { b: 2 } };
+      const cloned = cloneDeep(obj);
+      expect(cloned).toEqual(obj);
+      cloned.a.b = 99;
+      expect(obj.a.b).toBe(2);
+    });
+
+    test('clones Date objects', () => {
+      const date = new Date();
+      const cloned = cloneDeep(date);
+      expect(cloned).not.toBe(date);
+      expect(cloned.getTime()).toBe(date.getTime());
+    });
+
+    test('clones RegExp objects', () => {
+      const regex = /test/gi;
+      const cloned = cloneDeep(regex);
+      expect(cloned).not.toBe(regex);
+      expect(cloned.source).toBe(regex.source);
+      expect(cloned.flags).toBe(regex.flags);
+    });
+  });
+
+  describe('omit', () => {
+    test('omits specified keys from object', () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(omit(obj, 'a', 'c')).toEqual({ b: 2 });
+    });
+
+    test('supports array of keys to omit', () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(omit(obj, ['b'])).toEqual({ a: 1, c: 3 });
+    });
+
+    test('returns empty object for null or non-object input', () => {
+      expect(omit(null, 'a')).toEqual({});
+      expect(omit("string", 'a')).toEqual({});
+    });
+
+    test('returns original object if no keys match', () => {
+      const obj = { a: 1, b: 2 };
+      expect(omit(obj, 'c')).toEqual({ a: 1, b: 2 });
+    });
+  });
+
+  describe('debounce', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    test('delays execution until wait time has passed', () => {
+      const func = jest.fn();
+      const debounced = debounce(func, 1000);
+      debounced();
+      expect(func).not.toHaveBeenCalled();
+      jest.advanceTimersByTime(500);
+      expect(func).not.toHaveBeenCalled();
+      jest.advanceTimersByTime(500);
+      expect(func).toHaveBeenCalledTimes(1);
+    });
+
+    test('calls function only once when called repeatedly', () => {
+      const func = jest.fn();
+      const debounced = debounce(func, 1000);
+      debounced();
+      debounced();
+      debounced();
+      jest.advanceTimersByTime(1000);
+      expect(func).toHaveBeenCalledTimes(1);
+    });
+
+    test('immediate option calls function on first call', () => {
+      const func = jest.fn();
+      const debounced = debounce(func, 1000, true);
+      debounced();
+      expect(func).toHaveBeenCalledTimes(1);
+      debounced();
+      debounced();
+      jest.advanceTimersByTime(1000);
+      expect(func).toHaveBeenCalledTimes(1);
+    });
+
+    test('subsequent call after wait period works with immediate option', () => {
+      const func = jest.fn();
+      const debounced = debounce(func, 1000, true);
+      debounced();
+      jest.advanceTimersByTime(1100);
+      debounced();
+      expect(func).toHaveBeenCalledTimes(2);
+    });
+  });
 });

data/app/pb_kits/playbook/utilities/object.ts

@@ -1,6 +1,7 @@
 /* 🛠️ Any commonly used lodash functions can be added here. 🤙 */
 
-export const isEmpty = (obj: any) => [Object, Array].includes((obj || {}).constructor) && !Object.entries((obj || {})).length;
+export const isEmpty = (obj: any) =>
+  [Object, Array].includes((obj || {}).constructor) && !Object.entries((obj || {})).length
 
 export const get = <T, R = any>(obj: T, path: string, defaultValue?: R): R | any => {
   const travel = (regexp: RegExp): any =>
@@ -24,94 +25,175 @@ export const omitBy = (obj: Record<string, any>, predicate: (value: any, key: st
   if (obj === null || typeof obj !== 'object') return {}
   return Object.keys(obj).reduce((result: Record<string, any>, key: string) => {
     if (!predicate(obj[key], key)) {
-      result[key] = obj[key];
+      result[key] = obj[key]
     }
-    return result;
+    return result
   }, {})
 }
 
+export const omit = (
+  obj: Record<string, any>,
+  ...paths: (string | string[])[]
+): Record<string, any> => {
+  if (obj === null || typeof obj !== 'object') return {}
+  const keysToOmit = new Set<string>()
+  paths.forEach(p => {
+    if (Array.isArray(p)) {
+      p.forEach(key => keysToOmit.add(key))
+    } else {
+      keysToOmit.add(p)
+    }
+  })
+  const result: Record<string, any> = {}
+  for (const key in obj) {
+    if (!keysToOmit.has(key)) {
+      result[key] = obj[key]
+    }
+  }
+  return result
+}
+
 export const noop = (): void => {
   // empty
-};
+}
+
+export const cloneDeep = (value: any): any => {
+  if (value === null || typeof value !== 'object') {
+    return value
+  }
+  if (Array.isArray(value)) {
+    return value.map(cloneDeep)
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime())
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags)
+  }
+  const clonedObj: any = {}
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      clonedObj[key] = cloneDeep(value[key])
+    }
+  }
+  return clonedObj
+}
 
 export function merge(
   ...objects: Array<Record<string, unknown> | null | undefined>
 ): Record<string, unknown> {
   const isPlainObject = (obj: unknown): obj is Record<string, unknown> =>
-    !!obj && typeof obj === 'object' && !Array.isArray(obj);
+    !!obj && typeof obj === 'object' && !Array.isArray(obj)
 
-  const result: Record<string, unknown> = {};
+  const result: Record<string, unknown> = {}
 
   for (const obj of objects) {
-    if (!obj || typeof obj !== 'object') continue;
+    if (!obj || typeof obj !== 'object') continue
 
     for (const key of Object.keys(obj)) {
-      const oldVal = result[key];
-      const newVal = (obj as Record<string, unknown>)[key];
+      const oldVal = result[key]
+      const newVal = (obj as Record<string, unknown>)[key]
 
       if (Array.isArray(oldVal) && Array.isArray(newVal)) {
-        result[key] = newVal;
+        result[key] = newVal
       } else if (isPlainObject(oldVal) && isPlainObject(newVal)) {
-        result[key] = merge(oldVal, newVal);
+        result[key] = merge(oldVal, newVal)
       } else if (Array.isArray(oldVal) && isPlainObject(newVal)) {
-        result[key] = oldVal;
+        result[key] = oldVal
       } else if (isPlainObject(oldVal) && Array.isArray(newVal)) {
-        result[key] = oldVal;
+        result[key] = oldVal
       } else {
-        result[key] = newVal;
+        result[key] = newVal
       }
     }
   }
-  return result;
+  return result
 }
 
 const createIteratee = (predicate: any) => {
   if (typeof predicate === 'function') {
-    return predicate;
+    return predicate
   }
   if (typeof predicate === 'string') {
-    return (obj: any) => obj[predicate];
+    return (obj: any) => obj[predicate]
   }
   if (Array.isArray(predicate)) {
-    const [key, value] = predicate;
-    return (obj: any) => obj[key] === value;
+    const [key, value] = predicate
+    return (obj: any) => obj[key] === value
   }
   if (typeof predicate === 'object' && predicate !== null) {
     return (obj: any) => {
       for (const key in predicate) {
         if (Object.prototype.hasOwnProperty.call(predicate, key)) {
-          if (obj[key] !== predicate[key]) return false;
+          if (obj[key] !== predicate[key]) return false
         }
       }
-      return true;
-    };
+      return true
+    }
   }
-  return () => false;
-};
+  return () => false
+}
 
 export const filter = <T>(array: T[], predicate: any): T[] => {
-  const iteratee = createIteratee(predicate);
-  return array.filter(iteratee);
-};
+  const iteratee = createIteratee(predicate)
+  return array.filter(iteratee)
+}
 
 export const find = <T>(array: T[], predicate: any): T | undefined => {
-  const iteratee = createIteratee(predicate);
-  return array.find(iteratee);
-};
+  const iteratee = createIteratee(predicate)
+  return array.find(iteratee)
+}
 
-export const partial = <F extends (...args: unknown[]) => unknown>(
+export const partial = <F extends (...args: any[]) => any>(
   fn: F,
-  ...partials: unknown[]
-): ((...args: unknown[]) => ReturnType<F>) => {
-  const placeholder = partial.placeholder;
-  return (...args: unknown[]): ReturnType<F> => {
-    let argIndex = 0;
+  ...partials: any[]
+): ((...args: any[]) => ReturnType<F>) => {
+  const placeholder = partial.placeholder
+  return (...args: any[]): ReturnType<F> => {
+    let argIndex = 0
     const finalArgs = partials.map(arg =>
       arg === placeholder ? args[argIndex++] : arg
-    );
-    return fn(...(finalArgs.concat(args.slice(argIndex)) as Parameters<F>)) as ReturnType<F>;
-  };
-};
+    )
+    return fn(...(finalArgs.concat(args.slice(argIndex)) as Parameters<F>)) as ReturnType<F>
+  }
+}
 
-partial.placeholder = Symbol();
-export const _ = partial.placeholder;
+partial.placeholder = Symbol()
+export const _ = partial.placeholder
+
+export const map = <T, U>(
+  collection: T[] | Record<string, T>,
+  iteratee?: ((value: T, index: number | string, collection: T[] | Record<string, T>) => U) | string
+): U[] => {
+  const fn =
+    typeof iteratee === "function"
+      ? iteratee
+      : typeof iteratee === "string"
+      ? (item: T) => (item as any)[iteratee]
+      : (item: T) => item as unknown as U
+
+  if (Array.isArray(collection)) {
+    return collection.map((value, index) => fn(value, index, collection))
+  }
+  return Object.keys(collection).map(key => fn(collection[key], key, collection))
+}
+
+export function debounce<F extends (...args: any[]) => any>(
+  func: F,
+  wait: number,
+  immediate?: boolean
+): (...args: Parameters<F>) => void {
+  let timeout: ReturnType<typeof setTimeout> | null;
+  return function(this: any, ...args: any[]) {
+    if (timeout) clearTimeout(timeout);
+    if (immediate && !timeout) {
+      func.apply(this, args);
+    }
+    timeout = setTimeout(() => {
+      timeout = null;
+      if (!immediate) {
+        func.apply(this, args);
+      }
+    }, wait);
+  };
+}