playbook_ui 14.16.0.pre.rc.6 → 14.16.0

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

@@ -29,3 +29,89 @@ export const omitBy = (obj: Record<string, any>, predicate: (value: any, key: st
     return result;
   }, {})
 }
+
+export const noop = (): void => {
+  // empty
+};
+
+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: unknown[]) => unknown>(
+  fn: F,
+  ...partials: unknown[]
+): ((...args: unknown[]) => ReturnType<F>) => {
+  const placeholder = partial.placeholder;
+  return (...args: unknown[]): 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;

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

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