magic-utils-yonava 1.0.0

package/src/sets.ts

@@ -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 = <T>(sets: Set<T>[]) => {
+  return sets.reduce((acc, set) => new Set([...acc, ...set]), new Set<T>());
+};

package/src/string.test.ts

@@ -0,0 +1,17 @@
+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/string.ts

@@ -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: string) =>
+  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: string) => {
+  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;
+};

package/src/types.ts

@@ -0,0 +1,79 @@
+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-@-!!!'][]
+>;
+
+// HTML mouse and keyboard event types
+
+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>;

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist/types",
+    "rootDir": "./src",
+
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["node"],
+    "moduleResolution": "node",
+    "allowJs": false,
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+  },
+  "include": ["src/**/*"],
+}