magic-utils-yonava 1.0.2 → 1.0.4

package/dist/utils/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/dist/utils/sets.js

@@ -0,0 +1,10 @@
+/**
+ * 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 const mergeSetArrayIntoSet = (sets) => {
+    return sets.reduce((acc, set) => new Set([...acc, ...set]), new Set());
+};

package/dist/utils/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/dist/utils/string.js

@@ -0,0 +1,31 @@
+/**
+ * makes the first letter of a string uppercase
+ *
+ * @param str - the string to capitalize
+ * @returns the capitalized string
+ * @example capitalize('hello') // 'Hello'
+ */
+export const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+/**
+ * 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 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) => {
+    if (arr.length === 0)
+        return '';
+    if (arr.length === 1)
+        return arr[0];
+    const last = arr.pop();
+    return arr.join(', ') + ' and ' + last;
+};

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

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

package/dist/utils/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/dist/utils/types.d.ts

@@ -0,0 +1,54 @@
+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>>>;
+/**
+ * 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>>>;
+/**
+ * takes `any[]` out of a union of arrays
+ * @example RemoveAnyArray<number[] | any[]> // number[]
+ */
+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;
+}[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
+][];
+export type KeyboardEventEntries = [
+    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 Push<T extends any[], V> = [...T, V];
+type UnionToTuple<T, L = LastOf<T>> = [T] extends [never] ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+/**
+ * turns the keys of an object into a tuple
+ *
+ * WARNING: order is not guaranteed! for deterministic ordering use
+ * readonly runtime array instead
+ *
+ * @example
+ * ObjectKeysToTuple<{ name: string, age: number, id: string }>
+ * // ["name", "age", "id"]
+ */
+export type ObjectKeysToTuple<T extends object> = UnionToTuple<keyof T>;
+export {};

package/dist/utils/types.js

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

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "magic-utils-yonava",
-  "version": "1.0.2",
+  "version": "1.0.4",
+  "files": [
+    "dist"
+  ],
   "exports": {
     "./*": "./dist/*"
   },

package/src/clone.test.ts

@@ -1,47 +0,0 @@
-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 } } as any;
-  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: any) => node.size;
-  const nodeBorderWidth = (node: any) => 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);
-});

package/src/clone.ts

@@ -1,15 +0,0 @@
-/**
- * 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: Record<any, any>) => {
-  const cloned = { ...obj };
-  for (const key in cloned) {
-    if (typeof cloned[key] === 'object') {
-      cloned[key] = clone(cloned[key]);
-    }
-  }
-  return cloned;
-};

package/src/ctx/index.ts

@@ -1,20 +0,0 @@
-import type { MaybeRef } from 'vue';
-
-/**
- * pulls ctx from a canvas or canvas ref (vue.js), throws if not found
- *
- * @returns {CanvasRenderingContext2D}
- * @example const ctx = getCtx(canvasRef);
- * // ctx is defined and ready to use
- * @throws {Error} if canvas or 2d context not found
- */
-export const getCtx = (
-  canvasInput: MaybeRef<HTMLCanvasElement | null | undefined>,
-) => {
-  if (!canvasInput) throw new Error('canvas not found');
-  const canvas = 'value' in canvasInput ? canvasInput.value : canvasInput;
-  if (!canvas) throw new Error('canvas not found');
-  const ctx = canvas.getContext('2d');
-  if (!ctx) throw new Error('2d context not found');
-  return ctx;
-};

package/src/debugging.ts

@@ -1,23 +0,0 @@
-export const useLogReport = <T = string>(
-  frequencyMs = 1000,
-  resetReportAfterLogging = true,
-) => {
-  const report = new Set<T>();
-  const logReport = () => {
-    console.log(Array.from(report));
-    if (resetReportAfterLogging) report.clear();
-  };
-  setInterval(logReport, frequencyMs);
-  return report;
-};
-
-export const useCooldownLog = (frequencyMs = 1000) => {
-  let cooldown = false;
-  const log = (...data: any[]) => {
-    if (cooldown) return;
-    console.log(...data);
-    cooldown = true;
-  };
-  setInterval(() => (cooldown = false), frequencyMs);
-  return log;
-};

package/src/deepDelta/delta.test.ts

@@ -1,129 +0,0 @@
-import { expect, test } from 'vitest';
-
-import { delta } from '.';
-
-test('deepDelta standard', () => {
-  const yona = {
-    name: 'yona',
-    sex: 'm',
-    residence: 'amherst',
-    school: {
-      name: 'umass',
-      year: 'senior',
-      info: {
-        major: ['cs'],
-        minor: [],
-        start: '2023',
-      },
-    },
-    test: {
-      hello: 'world',
-      removeMe: {
-        removeMe: 'removeMe',
-        removeMe2: {},
-      },
-      test2: {
-        test3: 'secret',
-      },
-    },
-  };
-
-  const dila = {
-    name: 'dila',
-    sex: 'f',
-    residence: 'amherst',
-    school: {
-      name: 'umass',
-      year: 'junior',
-      info: {
-        major: ['cs', 'japanese'],
-        minor: [],
-        start: '2022',
-      },
-    },
-    test: {
-      hello: 'world',
-      removeMe: {
-        removeMe: 'removeMe',
-        removeMe2: {},
-      },
-      test2: {
-        test3: 'secret changed',
-      },
-    },
-  };
-
-  const expected = {
-    name: 'dila',
-    sex: 'f',
-    school: {
-      year: 'junior',
-      info: {
-        major: ['cs', 'japanese'],
-        start: '2022',
-      },
-    },
-    test: {
-      test2: {
-        test3: 'secret changed',
-      },
-    },
-  };
-
-  const result = delta(yona, dila);
-  expect(result).toEqual(expected);
-});
-
-test('deepDelta works if new object has more keys', () => {
-  const yona = {
-    name: 'yona',
-  };
-
-  const dila = {
-    name: 'dila',
-    favoriteColor: 'blue',
-    anime: {
-      naruto: 'meh',
-      bleach: 'good',
-    },
-  };
-
-  const expected = {
-    name: 'dila',
-    favoriteColor: 'blue',
-    anime: {
-      naruto: 'meh',
-      bleach: 'good',
-    },
-  };
-
-  const result = delta(yona, dila);
-
-  expect(result).toEqual(expected);
-});
-
-test('deepDelta works on fields that are null or undefined', () => {
-  const colorGetter = () => 'blue';
-
-  const yona = {
-    name: 'yona',
-    favoriteColor: {
-      color: colorGetter,
-    },
-    sbahn: 's1',
-  };
-
-  const dila = {
-    name: 'dila',
-    favoriteColor: null,
-    sbahn: undefined,
-  };
-
-  const expected = {
-    name: 'dila',
-    sbahn: undefined,
-  };
-
-  const result = delta(yona, dila);
-  expect(result).toEqual(expected);
-});

package/src/deepDelta/index.ts

@@ -1,48 +0,0 @@
-// recursively compare two objects and return the delta
-
-// -----------------
-
-const isObj = (obj: any) =>
-  Object.prototype.toString.call(obj) === '[object Object]';
-
-/**
- * gets the delta between two objects
- *
- * @param oldObject
- * @param newObject
- * @returns an object with only the changes, the values are the new values
- */
-export const delta = (
-  oldObject: Record<any, any>,
-  newObject: Record<any, any>,
-) => {
-  const output: Record<any, any> = {};
-
-  if (!oldObject) return newObject;
-  if (!newObject) return null;
-
-  const oldObjectKeys = Object.keys(oldObject);
-  const newObjectKeys = Object.keys(newObject);
-
-  for (const key of newObjectKeys) {
-    if (!oldObjectKeys.includes(key)) {
-      output[key] = newObject[key];
-    }
-  }
-
-  for (const key of oldObjectKeys) {
-    if (isObj(oldObject[key])) {
-      const diffObj = delta(oldObject[key], newObject[key]);
-      if (diffObj) output[key] = diffObj;
-      continue;
-    }
-
-    if (Array.isArray(oldObject[key])) {
-      if (JSON.stringify(oldObject[key]) !== JSON.stringify(newObject[key]))
-        output[key] = newObject[key];
-      continue;
-    } else if (oldObject[key] !== newObject[key]) output[key] = newObject[key];
-  }
-
-  return Object.keys(output).length ? output : null;
-};

package/src/deepMerge.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { deepMerge } from './deepMerge';
-
-describe('deepMerge', () => {
-  it('merges flat objects with rightmost priority', () => {
-    const result = deepMerge({ a: 1 }, { a: 2, b: 3 });
-    expect(result).toEqual({ a: 2, b: 3 });
-  });
-
-  it('merges nested objects deeply', () => {
-    const result = deepMerge({ a: { b: 1, c: 2 } }, { a: { b: 3, d: 4 } });
-    expect(result).toEqual({ a: { b: 3, c: 2, d: 4 } });
-  });
-
-  it('overwrites arrays instead of merging them', () => {
-    const result = deepMerge(
-      { a: [1, 2], b: { c: [3, 4] } },
-      { a: [5], b: { c: [6] } },
-    );
-    expect(result).toEqual({ a: [5], b: { c: [6] } });
-  });
-
-  it('handles primitive overwrites correctly', () => {
-    const result = deepMerge({ a: { b: 1 } }, { a: 5 });
-    expect(result).toEqual({ a: 5 });
-  });
-
-  it('returns non-object when passed a primitive last', () => {
-    const result = deepMerge({ a: 1 }, 5);
-    expect(result).toBe(5);
-  });
-
-  it('handles merging with undefined and null safely', () => {
-    const result = deepMerge({ a: { b: 1 } }, undefined, null, { a: { c: 2 } });
-    expect(result).toEqual({ a: { b: 1, c: 2 } });
-  });
-
-  it('handles empty inputs', () => {
-    const result = deepMerge();
-    expect(result).toEqual({});
-  });
-});
-
-describe('deepMerge - special cases', () => {
-  it('overwrites Date objects', () => {
-    const date1 = new Date('2020-01-01');
-    const date2 = new Date('2021-01-01');
-
-    const result = deepMerge({ date: date1 }, { date: date2 });
-    expect(result.date).toBe(date2);
-  });
-
-  it('overwrites Map objects', () => {
-    const map1 = new Map([['a', 1]]);
-    const map2 = new Map([['b', 2]]);
-
-    const result = deepMerge({ map: map1 }, { map: map2 });
-    expect(result.map).toBe(map2);
-  });
-
-  it('overwrites Set objects', () => {
-    const set1 = new Set([1, 2]);
-    const set2 = new Set([3, 4]);
-
-    const result = deepMerge({ set: set1 }, { set: set2 });
-    expect(result.set).toBe(set2);
-  });
-
-  it('overwrites functions', () => {
-    const fn1 = () => 1;
-    const fn2 = () => 2;
-
-    const result = deepMerge({ fn: fn1 }, { fn: fn2 });
-    expect(result.fn).toBe(fn2);
-    expect(result.fn()).toBe(2);
-  });
-
-  it('overwrites class instances', () => {
-    class Example {
-      x = 1;
-    }
-    const obj1 = { instance: new Example() };
-    const obj2 = { instance: { y: 2 } };
-
-    const result = deepMerge(obj1, obj2);
-    expect(result.instance).toEqual({ y: 2 });
-  });
-});

package/src/deepMerge.ts

@@ -1,37 +0,0 @@
-export const isPlainObject = (
-  obj: any,
-): obj is Record<string | number | symbol, unknown> =>
-  !!obj &&
-  typeof obj === 'object' &&
-  Object.getPrototypeOf(obj) === Object.prototype;
-
-/**
- * Deeply merges multiple objects. Properties from later objects overwrite those from earlier ones.
- * Non-object values (including arrays) are replaced, not merged.
- *
- * @param {...any[]} objects - Objects to merge. The rightmost object's properties take precedence.
- * @returns {any} - A new deeply merged object.
- *
- * @example
- * const result = deepMerge(
- *   { a: 1, b: { c: 2 } },
- *   { b: { d: 3 }, e: 4 }
- * );
- * // result: { a: 1, b: { c: 2, d: 3 }, e: 4 }
- */
-export const deepMerge = (...objects: any[]): any =>
-  objects.reduce((acc, obj) => {
-    if (obj === undefined || obj === null) return acc;
-
-    if (!isPlainObject(obj)) return obj;
-
-    Object.keys(obj).forEach((key) => {
-      if (isPlainObject(obj[key]) && isPlainObject(acc[key])) {
-        acc[key] = deepMerge(acc[key], obj[key]);
-      } else {
-        acc[key] = obj[key];
-      }
-    });
-
-    return acc;
-  }, {});

package/src/fps.ts

@@ -1,64 +0,0 @@
-import { onMounted, onUnmounted, ref } from "vue";
-
-export function useFPS() {
-  const fps = ref(0);
-  const frameTime = ref(0);
-  const slowFrameCount = ref(0);
-  const slowFrameRatio = ref(0);
-
-  let frameId: number;
-  let intervalId: NodeJS.Timeout;
-
-  let lastMeasure = performance.now();
-  let lastFrame = performance.now();
-  let frames = 0;
-  let slowFrames = 0;
-
-  const SLOW_FRAME_THRESHOLD = 33.3; // ms
-
-  const update = () => {
-    const now = performance.now();
-    const delta = now - lastFrame;
-    frameTime.value = delta;
-    lastFrame = now;
-
-    if (delta > SLOW_FRAME_THRESHOLD) {
-      slowFrames++;
-    }
-
-    frames++;
-    frameId = requestAnimationFrame(update);
-  };
-
-  const measure = () => {
-    const now = performance.now();
-    const delta = now - lastMeasure;
-
-    fps.value = Math.round((frames * 1000) / delta);
-    slowFrameCount.value = slowFrames;
-    slowFrameRatio.value = frames > 0 ? slowFrames / frames : 0;
-
-    frames = 0;
-    slowFrames = 0;
-    lastMeasure = now;
-  };
-
-  onMounted(() => {
-    lastFrame = performance.now();
-    lastMeasure = performance.now();
-    frameId = requestAnimationFrame(update);
-    intervalId = setInterval(measure, 500);
-  });
-
-  onUnmounted(() => {
-    cancelAnimationFrame(frameId);
-    clearInterval(intervalId);
-  });
-
-  return {
-    fps,
-    frameTime,
-    slowFrameCount,
-    slowFrameRatio,
-  };
-}

package/src/fracDecConverter/index.ts

@@ -1,36 +0,0 @@
-
-export const gcd = (a: number, b: number): number => (b ? gcd(b, a % b) : a);
-
-export const isNullOrUnd = (input: any) =>
-  input === null || input === undefined;
-
-export const isFraction = (input: string) => {
-  const fraction = input.trim().split('/').filter(Boolean);
-  if (fraction.length !== 2) return false;
-  const [numerator, denominator] = fraction.map(Number);
-  if (isNullOrUnd(numerator) || isNullOrUnd(denominator)) return false;
-  return true;
-};
-
-export const decimalToFraction = (decimalInput: number) => {
-  const decimal = Math.round(decimalInput * 1e10) / 1e10;
-  const len = decimal.toString().length - 2;
-  let denominator = 10 ** len;
-  let numerator = decimal * denominator;
-  const divisor = gcd(numerator, denominator);
-  numerator /= divisor;
-  denominator /= divisor;
-  if (denominator === 1) return numerator.toString();
-  return `${numerator}/${denominator}`;
-};
-
-/**
- * @param fractionInput  a string representing a fraction
- * @returns the decimal representation of the fraction or undefined if the input is not a fraction
- */
-export const fractionToDecimal = (fractionInput: string) => {
-  if (!isFraction(fractionInput)) return;
-  const fraction = fractionInput.split('/');
-  const [numerator, denominator] = fraction.map(Number);
-  return numerator / denominator;
-};

package/src/hashing.ts

@@ -1,9 +0,0 @@
-export const djb2Hasher = (str: string) => {
-  let hash = 5381;
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash << 5) + hash + str.charCodeAt(i);
-  }
-  return hash >>> 0;
-};
-
-export type DJB2Hash = ReturnType<typeof djb2Hasher>;