@silvermine/toolbox 0.1.0 → 0.3.0

package/src/utils/pick.ts

@@ -0,0 +1,24 @@
+import { isArray } from './is-array';
+
+// NOTE: If changing these types, ensure the following cases cause a type error:
+//
+// const noProps = pick({ a: 1 });
+//
+// noProps.a; // Property 'a' does not exist on type 'Pick<{ a: number; }, never>'.
+//
+// const emptyArr = pick({ a: 1 }, []);
+//
+// emptyArr.a; // Property 'a' does not exist on type 'Pick<{ a: number; }, never>'.
+
+export function pick<T extends object, K extends keyof T>(obj: T, props: K[]): Pick<T, K>;
+export function pick<T extends object, K extends keyof T = never>(obj: T, ...props: K[]): Pick<T, K>;
+export function pick<T extends object, K extends keyof T>(obj: T, ...args: K[] | [ K[] ]): Pick<T, K> {
+   const props = ((args.length === 1 && isArray(args[0])) ? args[0] : args) as K[];
+
+   return props.reduce((memo, prop) => {
+      if (prop in obj) {
+         memo[prop] = obj[prop];
+      }
+      return memo;
+   }, {} as Pick<T, K>);
+}

package/src/utils/pluck.ts

@@ -1,4 +1,4 @@
-export function pluck<T, K extends keyof T>(sources: T[], key: K): T[K][] {
+export function pluck<T, K extends keyof T>(sources: readonly T[], key: K): T[K][] {
    return sources.map((o) => {
       return o[key];
    });

package/src/utils/uniq.ts

@@ -0,0 +1,59 @@
+const iterateeUniq = <T, U>(arr: T[], iteratee: (value: T, i: number, arr: T[]) => U): T[] => {
+   const result: T[] = [],
+         seen: U[] = [];
+
+   for (let i = 0, length = arr.length; i < length; i++) {
+      let value = arr[i],
+          computed = iteratee(value, i, arr);
+
+      if (seen.indexOf(computed) === -1) {
+         seen.push(computed);
+         result.push(value);
+      }
+   }
+   return result;
+};
+
+
+const sortedUniq = <T, U>(arr: T[]): T[] => {
+   const result: T[] = [];
+
+   let lastSeen: T | U | undefined;
+
+   for (let i = 0, length = arr.length; i < length; i++) {
+      let value = arr[i];
+
+      if (i === 0 || lastSeen !== value) {
+         result.push(value);
+      }
+      lastSeen = value;
+   }
+   return result;
+};
+
+
+const standardUniq = <T>(arr: T[]): T[] => {
+   const result = arr.filter((value, index, _arr) => {
+      return _arr.indexOf(value) === index;
+   });
+
+   return result;
+};
+
+
+/**
+ * Produce a duplicate-free version of the array. If the array has already
+ * been sorted, you have the option of using a faster algorithm.
+ * The faster algorithm will not work with an iteratee if the iteratee
+ * is not a one-to-one function, so providing an iteratee will disable
+ * the faster algorithm.
+ */
+export const uniq = <T, U>(arr: T[], isSorted?: boolean, iteratee?: (value: T, i: number, arr: T[]) => U): T[] => {
+   if (iteratee) {
+      return iterateeUniq(arr, iteratee);
+   }
+   if (isSorted) {
+      return sortedUniq(arr);
+   }
+   return standardUniq(arr);
+};