playbook_ui 14.16.0.pre.alpha.play1964tablekitheadertextstylefix7091 → 14.16.0.pre.rc.0

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

@@ -1,4 +1,4 @@
-import { omit } from './object'
+import { omit } from 'lodash'
 import { camelToSnakeCase } from './text'
 
 import {

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

@@ -1,4 +1,4 @@
-import { isEmpty, get, isString, uniqueId, omitBy, noop, merge, filter, find, partial, map, cloneDeep, omit, debounce } from './object';
+import { isEmpty, get, isString, uniqueId, omitBy } from './object';
 
 describe('Lodash functions', () => {
   describe('isEmpty', () => {
@@ -96,290 +96,4 @@ describe('Lodash functions', () => {
       expect(objWithSmallValues).toEqual(obj);
     });
   });
-
-  describe('noop', () => {
-    test('should do nothing and return undefined', () => {
-      expect(noop()).toBeUndefined();
-    });
-  });
-
-  describe('merge', () => {
-    test('merges two objects correctly', () => {
-      const obj1 = { a: 1, b: { x: 10 } };
-      const obj2 = { b: { y: 20 }, c: 3 };
-      expect(merge(obj1, obj2)).toEqual({ a: 1, b: { x: 10, y: 20 }, c: 3 });
-    });
-
-    test('when keys repeat use last occurrence value', () => {
-      const obj1 = { a: 1 };
-      const obj2 = { b: 2 };
-      const obj3 = { a: 3, c: 4 };
-      expect(merge(obj1, obj2, obj3)).toEqual({ a: 3, b: 2, c: 4 });
-    });
-
-    test('ignores non-object arguments', () => {
-      expect(merge(null, { a: 1 })).toEqual({ a: 1 });
-      expect(merge(undefined, { a: 1 })).toEqual({ a: 1 });
-    });
-  });
-
-  describe('filter', () => {
-    test('filters an array using a function predicate', () => {
-      const arr = [1, 2, 3, 4, 5];
-      const isEven = (n) => n % 2 === 0;
-      expect(filter(arr, isEven)).toEqual([2, 4]);
-    });
-
-    test('filters an array using a string predicate', () => {
-      const arr = [
-        { active: true, name: 'John' },
-        { active: false, name: 'Jane' },
-        { active: true, name: 'Doe' }
-      ];
-      expect(filter(arr, 'active')).toEqual([
-        { active: true, name: 'John' },
-        { active: true, name: 'Doe' }
-      ]);
-    });
-
-    test('filters an array using an array predicate', () => {
-      const arr = [
-        { type: 'fruit', name: 'apple' },
-        { type: 'vegetable', name: 'carrot' },
-        { type: 'fruit', name: 'banana' }
-      ];
-      expect(filter(arr, ['type', 'fruit'])).toEqual([
-        { type: 'fruit', name: 'apple' },
-        { type: 'fruit', name: 'banana' }
-      ]);
-    });
-
-    test('filters an array using an object predicate', () => {
-      const arr = [
-        { type: 'fruit', name: 'apple', color: 'red' },
-        { type: 'fruit', name: 'banana', color: 'yellow' },
-        { type: 'vegetable', name: 'carrot', color: 'orange' }
-      ];
-      expect(filter(arr, { type: 'fruit', color: 'red' })).toEqual([
-        { type: 'fruit', name: 'apple', color: 'red' }
-      ]);
-    });
-  });
-
-  describe('find', () => {
-    test('finds an element using a function predicate', () => {
-      const arr = [1, 2, 3, 4, 5];
-      const greaterThanThree = (n) => n > 3;
-      expect(find(arr, greaterThanThree)).toBe(4);
-    });
-
-    test('finds an element using a string predicate', () => {
-      const arr = [
-        { active: false, name: 'John' },
-        { active: true, name: 'Jane' },
-        { active: true, name: 'Doe' }
-      ];
-      expect(find(arr, 'active')).toEqual({ active: true, name: 'Jane' });
-    });
-
-    test('finds an element using an array predicate', () => {
-      const arr = [
-        { type: 'fruit', name: 'apple' },
-        { type: 'vegetable', name: 'carrot' },
-        { type: 'fruit', name: 'banana' }
-      ];
-      expect(find(arr, ['type', 'vegetable'])).toEqual({ type: 'vegetable', name: 'carrot' });
-    });
-
-    test('finds an element using an object predicate', () => {
-      const arr = [
-        { type: 'fruit', name: 'apple', color: 'red' },
-        { type: 'fruit', name: 'banana', color: 'yellow' },
-        { type: 'vegetable', name: 'carrot', color: 'orange' }
-      ];
-      expect(find(arr, { name: 'banana', color: 'yellow' })).toEqual({ type: 'fruit', name: 'banana', color: 'yellow' });
-    });
-
-    test('returns undefined if no element matches', () => {
-      const arr = [{ id: 1 }, { id: 2 }];
-      expect(find(arr, { id: 3 })).toBeUndefined();
-    });
-  });
-
-  describe('partial', () => {
-    function add(a, b, c) {
-      return a + b + c;
-    }
-
-    test('partials arguments without placeholders', () => {
-      const add5 = partial(add, 2, 3);
-      expect(add5(4)).toBe(9);
-    });
-
-    test('partials arguments with placeholders', () => {
-      const addWithPlaceholder = partial(add, partial.placeholder, 3, partial.placeholder);
-      expect(addWithPlaceholder(2, 4)).toBe(9);
-    });
-
-    test('returns correct result when all arguments are pre-filled', () => {
-      const addAll = partial(add, 1, 2, 3);
-      expect(addAll()).toBe(6);
-    });
-
-    test('appends extra arguments when provided', () => {
-      function join(...args) {
-        return args.join('_');
-      }
-      const joinPartial = partial(join, 'a');
-      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,7 +1,6 @@
 /* 🛠️ 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 =>
@@ -25,175 +24,8 @@ 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)
-
-  const result: Record<string, unknown> = {}
-
-  for (const obj of objects) {
-    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]
-
-      if (Array.isArray(oldVal) && Array.isArray(newVal)) {
-        result[key] = newVal
-      } else if (isPlainObject(oldVal) && isPlainObject(newVal)) {
-        result[key] = merge(oldVal, newVal)
-      } else if (Array.isArray(oldVal) && isPlainObject(newVal)) {
-        result[key] = oldVal
-      } else if (isPlainObject(oldVal) && Array.isArray(newVal)) {
-        result[key] = oldVal
-      } else {
-        result[key] = newVal
-      }
-    }
-  }
-  return result
-}
-
-const createIteratee = (predicate: any) => {
-  if (typeof predicate === 'function') {
-    return predicate
-  }
-  if (typeof predicate === 'string') {
-    return (obj: any) => obj[predicate]
-  }
-  if (Array.isArray(predicate)) {
-    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
-        }
-      }
-      return true
-    }
-  }
-  return () => false
-}
-
-export const filter = <T>(array: T[], predicate: any): T[] => {
-  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)
-}
-
-export const partial = <F extends (...args: any[]) => any>(
-  fn: F,
-  ...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>
-  }
-}
-
-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);
-  };
-}

data/app/pb_kits/playbook/utilities/test/globalProps/display.test.js

@@ -9,7 +9,7 @@ const testSubject = 'body'
 
 // %w[block inline_block inline flex inline_flex none]
 test('Global Props: returns proper class name', () => {
-  const propValues = ["block", "inline", "inline_block", "flex", "inline_flex", "none", "grid" ]
+  const propValues = ["block", "inline", "inline_block", "flex", "inline_flex", "none"]
   for(let x = 0, y = propValues.length; x < y; ++x) {
     const testId = `${testSubject}-${propValues[x]}`
     render(

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

@@ -1,4 +1,4 @@
-import { filter } from './object'
+import { filter } from 'lodash'
 
 const isEmpty = (value: string | unknown): boolean => !value || value == ''