magic-utils-yonava 1.0.2 → 1.0.4

package/{src/math.ts → dist/math.js}

@@ -3,7 +3,6 @@
  * {@link} https://en.wikipedia.org/wiki/Golden_ratio
  */
 export const GOLDEN_RATIO = 1.618;
-
 /**
  * rounds a number to the nearest multiple of another number
  *
@@ -14,10 +13,9 @@ export const GOLDEN_RATIO = 1.618;
  * roundToNearest5(13) // 15
  * roundToNearest5(12) // 10
  */
-export const roundToNearestN = (nearest: number) => (n: number) => {
-  return Math.round(n / nearest) * nearest;
+export const roundToNearestN = (nearest) => (n) => {
+    return Math.round(n / nearest) * nearest;
 };
-
 /**
  * get the prime factors of a number
  *
@@ -26,22 +24,20 @@ export const roundToNearestN = (nearest: number) => (n: number) => {
  * @example getPrimeFactors(12) // [2, 2, 3]
  * getPrimeFactors(15) // [3, 5]
  */
-export const getPrimeFactors = (num: number) => {
-  const factors: number[] = [];
-  let divisor = 2;
-
-  while (num >= 2) {
-    if (num % divisor === 0) {
-      factors.push(divisor);
-      num = num / divisor;
-    } else {
-      divisor++;
+export const getPrimeFactors = (num) => {
+    const factors = [];
+    let divisor = 2;
+    while (num >= 2) {
+        if (num % divisor === 0) {
+            factors.push(divisor);
+            num = num / divisor;
+        }
+        else {
+            divisor++;
+        }
     }
-  }
-
-  return factors;
+    return factors;
 };
-
 /**
  * get the lowest prime factor of a number
  *
@@ -51,11 +47,11 @@ export const getPrimeFactors = (num: number) => {
  * lowestPrimeFactor(12) // 12 = 2 * 2 * 3, min(2, 2, 3) = 2
  * lowestPrimeFactor(15) // 15 = 3 * 5, min(3, 5) = 3
  */
-export const lowestPrimeFactor = (num: number) => {
-  if (num === 1) return 1; // 1 has no prime factors
-  return Math.min(...getPrimeFactors(num));
+export const lowestPrimeFactor = (num) => {
+    if (num === 1)
+        return 1; // 1 has no prime factors
+    return Math.min(...getPrimeFactors(num));
 };
-
 /**
  * get the greatest common divisor of two numbers.
  * {@link} https://en.wikipedia.org/wiki/Euclidean_algorithm
@@ -67,18 +63,17 @@ export const lowestPrimeFactor = (num: number) => {
  * @example gcd(12, 15) // 3
  * gcd(12, 18) // 6
  */
-export const gcd = (a: number, b: number): number => {
-  if (b === 0) return a;
-  return gcd(b, a % b);
+export const gcd = (a, b) => {
+    if (b === 0)
+        return a;
+    return gcd(b, a % b);
 };
-
 /**
  * check if two numbers are within a certain tolerance of each other
  */
-export const within = (tolerance: number) => (a: number, b: number) => {
-  return Math.abs(a - b) <= tolerance;
+export const within = (tolerance) => (a, b) => {
+    return Math.abs(a - b) <= tolerance;
 };
-
 /**
  * get the average of an array of numbers
  *
@@ -87,7 +82,8 @@ export const within = (tolerance: number) => (a: number, b: number) => {
  * @example average([1, 2, 3]) // 2
  * average([1, 2, 3, 4]) // 2.5
  */
-export const average = (arr: number[]) => {
-  if (arr.length === 0) return 0;
-  return arr.reduce((acc, val) => acc + val, 0) / arr.length;
+export const average = (arr) => {
+    if (arr.length === 0)
+        return 0;
+    return arr.reduce((acc, val) => acc + val, 0) / arr.length;
 };

package/dist/math.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { average, gcd, getPrimeFactors, lowestPrimeFactor, roundToNearestN, } from './math';
+describe('roundToNearestN', () => {
+    test('rounds a number to the nearest multiple of n', () => {
+        const roundToNearest5 = roundToNearestN(5);
+        expect(roundToNearest5(13)).toBe(15);
+        expect(roundToNearest5(12)).toBe(10);
+    });
+});
+describe('getPrimeFactors', () => {
+    test('returns the prime factors of a number', () => {
+        expect(getPrimeFactors(12)).toEqual([2, 2, 3]);
+        expect(getPrimeFactors(15)).toEqual([3, 5]);
+    });
+    test('edge case: 1', () => {
+        expect(getPrimeFactors(1)).toEqual([]);
+    });
+});
+describe('lowestPrimeFactor', () => {
+    test('returns the lowest prime factor of a number', () => {
+        expect(lowestPrimeFactor(12)).toBe(2);
+        expect(lowestPrimeFactor(15)).toBe(3);
+    });
+    test('edge case: 1', () => {
+        expect(lowestPrimeFactor(1)).toBe(1);
+    });
+});
+describe('gcd', () => {
+    test('returns the greatest common divisor of two numbers', () => {
+        expect(gcd(12, 15)).toBe(3);
+        expect(gcd(12, 18)).toBe(6);
+    });
+});
+describe('average', () => {
+    test('returns the average of a list of numbers', () => {
+        expect(average([1, 2, 3, 4, 5])).toBe(3);
+        expect(average([1, 2, 3, 4, 5, 6])).toBe(3.5);
+    });
+    test('edge case: empty list', () => {
+        expect(average([])).toBe(0);
+    });
+});

package/{src/maybeGetter/index.ts → dist/maybeGetter/index.d.ts}

@@ -1,5 +1,4 @@
 import type { RemoveAnyArray } from '../types';
-
 /**
  * taking some data that may be a plain value or a function that returns that value
  *
@@ -7,20 +6,14 @@ import type { RemoveAnyArray } from '../types';
  * @template K - the type of the arguments necessary in order to resolve the value
  */
 export type MaybeGetter<T, K extends any[] = []> = T | ((...arg: K) => T);
-
 /**
  * the value of a MaybeGetter
  */
-export type UnwrapMaybeGetter<T> =
-  T extends MaybeGetter<infer U, infer _> ? U : T;
-
+export type UnwrapMaybeGetter<T> = T extends MaybeGetter<infer U, infer _> ? U : T;
 /**
  * the parameters of a MaybeGetter
  */
-export type MaybeGetterParams<T> = RemoveAnyArray<
-  T extends MaybeGetter<infer _, infer K> ? K : []
->;
-
+export type MaybeGetterParams<T> = RemoveAnyArray<T extends MaybeGetter<infer _, infer K> ? K : []>;
 /**
  * unwraps a MaybeGetter into a value of type T.
  *
@@ -30,12 +23,4 @@ export type MaybeGetterParams<T> = RemoveAnyArray<
  * @example getValue(5) // 5
  * getValue(() => 5) // 5
  */
-export const getValue = <T, K extends any[]>(
-  value: MaybeGetter<T, K>,
-  ...args: K
-) => {
-  if (typeof value === 'function') {
-    return (value as (...args: K) => T)(...args);
-  }
-  return value;
-};
+export declare const getValue: <T, K extends any[]>(value: MaybeGetter<T, K>, ...args: K) => T;

package/dist/maybeGetter/index.js

@@ -0,0 +1,15 @@
+/**
+ * unwraps a MaybeGetter into a value of type T.
+ *
+ * @param value - the value to unwrap
+ * @param args - the arguments to pass to the getter if the value is a getter
+ * @returns T, which is UnwrapMaybeGetter<MaybeGetter<T, K>>
+ * @example getValue(5) // 5
+ * getValue(() => 5) // 5
+ */
+export const getValue = (value, ...args) => {
+    if (typeof value === 'function') {
+        return value(...args);
+    }
+    return value;
+};

package/dist/mouse.d.ts

@@ -0,0 +1,8 @@
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
+ */
+export declare const MOUSE_BUTTONS: {
+    readonly left: 0;
+    readonly middle: 1;
+    readonly right: 2;
+};

package/{src/mouse.ts → dist/mouse.js}

@@ -2,7 +2,7 @@
  * https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
  */
 export const MOUSE_BUTTONS = {
-  left: 0,
-  middle: 1,
-  right: 2,
-} as const;
+    left: 0,
+    middle: 1,
+    right: 2,
+};

package/dist/random.d.ts

@@ -0,0 +1,19 @@
+/**
+ * given two numbers, this function returns a random number between them (inclusive)
+ *
+ * @param min - the lowest number
+ * @param max - the highest number
+ * @returns a random number between min and max
+ */
+export declare const getRandomInRange: (min: number, max: number) => number;
+export declare const getRandomPointOnCanvas: (canvas: HTMLCanvasElement, buffer?: number) => {
+    x: number;
+    y: number;
+};
+/**
+ * get a random element from an array
+ *
+ * @param array
+ * @returns random element from given array
+ */
+export declare const getRandomElement: <T>(array: ArrayLike<T>) => T;

package/dist/random.js

@@ -0,0 +1,21 @@
+/**
+ * given two numbers, this function returns a random number between them (inclusive)
+ *
+ * @param min - the lowest number
+ * @param max - the highest number
+ * @returns a random number between min and max
+ */
+export const getRandomInRange = (min, max) => Math.round(Math.random() * (max - min) + min);
+export const getRandomPointOnCanvas = (canvas, buffer = 50) => ({
+    x: getRandomInRange(buffer, canvas.width - buffer),
+    y: getRandomInRange(buffer, canvas.height - buffer),
+});
+/**
+ * get a random element from an array
+ *
+ * @param array
+ * @returns random element from given array
+ */
+export const getRandomElement = (array) => {
+    return array[Math.floor(Math.random() * array.length)];
+};

package/dist/sets.d.ts

@@ -0,0 +1,8 @@
+/**
+ * combine an array of sets into a single set
+ *
+ * @param sets array of sets
+ * @returns a single set containing all elements from the input sets
+ * @example mergeSetArrayIntoSet([new Set([1, 2]), new Set([2, 3])]) // Set(1, 2, 3)
+ */
+export declare const mergeSetArrayIntoSet: <T>(sets: Set<T>[]) => Set<T>;

package/{src/sets.ts → dist/sets.js}

@@ -5,6 +5,6 @@
  * @returns a single set containing all elements from the input sets
  * @example mergeSetArrayIntoSet([new Set([1, 2]), new Set([2, 3])]) // Set(1, 2, 3)
  */
-export const mergeSetArrayIntoSet = <T>(sets: Set<T>[]) => {
-  return sets.reduce((acc, set) => new Set([...acc, ...set]), new Set<T>());
+export const mergeSetArrayIntoSet = (sets) => {
+    return sets.reduce((acc, set) => new Set([...acc, ...set]), new Set());
 };

package/dist/string.d.ts

@@ -0,0 +1,21 @@
+/**
+ * makes the first letter of a string uppercase
+ *
+ * @param str - the string to capitalize
+ * @returns the capitalized string
+ * @example capitalize('hello') // 'Hello'
+ */
+export declare const capitalize: (str: string) => string;
+/**
+ * turns a camelCase string into a title case string
+ *
+ * @param str - the string to convert
+ * @returns the title case string
+ * @example camelCaseToTitleCase('camelCase') // 'Camel Case'
+ */
+export declare const camelCaseToTitleCase: (str: string) => string;
+/**
+ * turns an array of strings into a comma separated list with 'and' before the last item
+ * @example toCommaList(['a', 'b', 'c']) // 'a, b and c'
+ */
+export declare const getCommaList: (arr: string[]) => string;

package/{src/string.ts → dist/string.js}

@@ -5,9 +5,7 @@
  * @returns the capitalized string
  * @example capitalize('hello') // 'Hello'
  */
-export const capitalize = (str: string) =>
-  str.charAt(0).toUpperCase() + str.slice(1);
-
+export const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 /**
  * turns a camelCase string into a title case string
  *
@@ -15,17 +13,19 @@ export const capitalize = (str: string) =>
  * @returns the title case string
  * @example camelCaseToTitleCase('camelCase') // 'Camel Case'
  */
-export const camelCaseToTitleCase = (str: string) => {
-  const result = str.replace(/([A-Z])/g, ' $1');
-  return capitalize(result);
+export const camelCaseToTitleCase = (str) => {
+    const result = str.replace(/([A-Z])/g, ' $1');
+    return capitalize(result);
 };
 /**
  * turns an array of strings into a comma separated list with 'and' before the last item
  * @example toCommaList(['a', 'b', 'c']) // 'a, b and c'
  */
-export const getCommaList = (arr: string[]) => {
-  if (arr.length === 0) return '';
-  if (arr.length === 1) return arr[0];
-  const last = arr.pop();
-  return arr.join(', ') + ' and ' + last;
+export const getCommaList = (arr) => {
+    if (arr.length === 0)
+        return '';
+    if (arr.length === 1)
+        return arr[0];
+    const last = arr.pop();
+    return arr.join(', ') + ' and ' + last;
 };

package/dist/string.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/string.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, test } from 'vitest';
+import { camelCaseToTitleCase, capitalize } from './string';
+describe('capitalize', () => {
+    test('capitalizes the first letter of a string', () => {
+        expect(capitalize('hello')).toBe('Hello');
+        expect(capitalize('this is one string')).toBe('This is one string');
+    });
+});
+describe('camelCaseToTitleCase', () => {
+    test('converts camelCase to title case', () => {
+        expect(camelCaseToTitleCase('camelCase')).toBe('Camel Case');
+        expect(camelCaseToTitleCase('thisIsOneString')).toBe('This Is One String');
+    });
+});

package/{src/types.ts → dist/types.d.ts}

@@ -1,71 +1,45 @@
 import type { Prettify, UnionToIntersection } from 'ts-essentials';
-
 /**
  * makes only certain keys K in an object T optional
  * @example
  * type T = PartiallyPartial<{ a: number, b: string }, 'a'> // { a?: number, b: string }
  */
-export type PartiallyPartial<T, K extends keyof T> = Prettify<
-  Omit<T, K> & Partial<Pick<T, K>>
->;
-
+export type PartiallyPartial<T, K extends keyof T> = Prettify<Omit<T, K> & Partial<Pick<T, K>>>;
 /**
  * makes only certain keys K in an object T required
  * @example
  * type T = PartiallyRequired<{ a?: number, b?: string }, 'a'> // { a: number, b?: string }
  */
-export type PartiallyRequired<T, K extends keyof T> = Prettify<
-  Omit<T, K> & Required<Pick<T, K>>
->;
-
+export type PartiallyRequired<T, K extends keyof T> = Prettify<Omit<T, K> & Required<Pick<T, K>>>;
 /**
  * takes `any[]` out of a union of arrays
  * @example RemoveAnyArray<number[] | any[]> // number[]
  */
-export type RemoveAnyArray<T extends unknown[]> = Exclude<
-  T,
-  ['!!!-@-NOT-A-TYPE-@-!!!'][]
->;
-
-// HTML mouse and keyboard event types
-
+export type RemoveAnyArray<T extends unknown[]> = Exclude<T, [
+    '!!!-@-NOT-A-TYPE-@-!!!'
+][]>;
 type EventNames = keyof HTMLElementEventMap;
-
 type FilterEventNames<T> = {
-  [K in EventNames]: HTMLElementEventMap[K] extends T ? K : never;
+    [K in EventNames]: HTMLElementEventMap[K] extends T ? K : never;
 }[EventNames];
-
 type MouseEventNames = FilterEventNames<MouseEvent>;
 type KeyboardEventNames = FilterEventNames<KeyboardEvent>;
-
 type EventMap<T extends EventNames, E> = Record<T, (ev: E) => void>;
-
 export type MouseEventMap = EventMap<MouseEventNames, MouseEvent>;
 export type KeyboardEventMap = EventMap<KeyboardEventNames, KeyboardEvent>;
-
 export type MouseEventEntries = [
-  keyof MouseEventMap,
-  (ev: MouseEvent) => void,
+    keyof MouseEventMap,
+    (ev: MouseEvent) => void
 ][];
 export type KeyboardEventEntries = [
-  keyof KeyboardEventMap,
-  (ev: KeyboardEvent) => void,
+    keyof KeyboardEventMap,
+    (ev: KeyboardEvent) => void
 ][];
-
 export type TimeoutHandler = ReturnType<typeof setTimeout>;
 export type IntervalHandler = ReturnType<typeof setInterval>;
-
-type LastOf<U> =
-  UnionToIntersection<U extends any ? () => U : never> extends () => infer R
-    ? R
-    : never;
-
+type LastOf<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? R : never;
 type Push<T extends any[], V> = [...T, V];
-
-type UnionToTuple<T, L = LastOf<T>> = [T] extends [never]
-  ? []
-  : Push<UnionToTuple<Exclude<T, L>>, L>;
-
+type UnionToTuple<T, L = LastOf<T>> = [T] extends [never] ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
 /**
  * turns the keys of an object into a tuple
  *
@@ -77,3 +51,4 @@ type UnionToTuple<T, L = LastOf<T>> = [T] extends [never]
  * // ["name", "age", "id"]
  */
 export type ObjectKeysToTuple<T extends object> = UnionToTuple<keyof T>;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/clone.d.ts

@@ -0,0 +1,9 @@
+/**
+ * clones an object while preserving the references of non-primitive values
+ *
+ * @param obj - the object to clone
+ * @returns the cloned object
+ */
+export declare const clone: (obj: Record<any, any>) => {
+    [x: string]: any;
+};

package/dist/utils/clone.js

@@ -0,0 +1,15 @@
+/**
+ * clones an object while preserving the references of non-primitive values
+ *
+ * @param obj - the object to clone
+ * @returns the cloned object
+ */
+export const clone = (obj) => {
+    const cloned = { ...obj };
+    for (const key in cloned) {
+        if (typeof cloned[key] === 'object') {
+            cloned[key] = clone(cloned[key]);
+        }
+    }
+    return cloned;
+};

package/dist/utils/clone.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/clone.test.js

@@ -0,0 +1,42 @@
+import { expect, test } from "vitest";
+import { clone } from "./clone";
+import { delta } from "./deepDelta";
+test("works on basic objects", () => {
+    const obj = { a: 1, b: 2 };
+    const cloned = clone(obj);
+    expect(cloned).not.toBe(obj);
+    expect(cloned).toEqual(obj);
+});
+test("works on nested objects", () => {
+    const obj = { a: { b: 1 } };
+    const cloned = clone(obj);
+    expect(cloned).not.toBe(obj);
+    expect(cloned).toEqual(obj);
+});
+test("works by preserving nested references", () => {
+    const objWithRef = { a: { b: () => { } }, c: { d: 1 } };
+    const cloned = clone(objWithRef);
+    objWithRef.c = {};
+    expect(cloned.a.b).toBe(objWithRef.a.b);
+    expect(cloned.c).toEqual({ d: 1 });
+});
+test("works with deep delta", () => {
+    const nodeSize = (node) => node.size;
+    const nodeBorderWidth = (node) => node.borderWidth;
+    const storedTheme = clone({
+        nodeSize,
+        nodeBorderWidth,
+        nodeBorderColor: "#000",
+        edgeWidth: 1,
+        edgeColor: "#123",
+    });
+    const incomingTheme = {
+        nodeSize,
+        nodeBorderWidth,
+        nodeBorderColor: "#000",
+        edgeWidth: 1,
+        edgeColor: "#123",
+    };
+    const diff = delta(storedTheme, incomingTheme);
+    expect(diff).toEqual(null);
+});