@heliosgraphics/utils 6.0.0-alpha.9

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Helios Graphics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/classnames.spec.ts

@@ -0,0 +1,17 @@
+import { it, describe, expect } from "vitest"
+import { getClasses } from "./classnames"
+
+describe("classnames", () => {
+	describe("getClasses", () => {
+		it("returns valid with string", () => expect(getClasses("burn")).toEqual("burn"))
+		it("returns conditional object", () =>
+			expect(getClasses("burn", { "burn--alternative": true })).toEqual("burn burn--alternative"))
+		it("returns valid with invalid", () =>
+			expect(
+				getClasses("burn", null, "burn", undefined, {
+					"burn--active": false,
+					"burn--loading": true,
+				}),
+			).toEqual("burn burn--loading"))
+	})
+})

package/classnames.ts

@@ -0,0 +1,21 @@
+export const getClasses = (...args: Array<unknown>): string => {
+	const classNames: Set<string> = new Set()
+
+	for (const item of args) {
+		const itemType = typeof item
+		const isValidString: boolean = itemType === "string" && (item as string).length > 0
+		const isValidObject: boolean = itemType === "object" && item !== null
+
+		if (isValidString) {
+			classNames.add(item as string)
+		}
+
+		if (isValidObject) {
+			for (const [key, value] of Object.entries(item as Record<string, unknown>)) {
+				if (value) classNames.add(key)
+			}
+		}
+	}
+
+	return Array.from(classNames).join(" ")
+}

package/clipboard.spec.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi } from "vitest"
+import { copyValue } from "./clipboard"
+
+const mockDocument = {
+	createElement: vi.fn(),
+	execCommand: vi.fn(),
+	body: {
+		appendChild: vi.fn(),
+	},
+} as unknown as Document
+
+global.document = mockDocument
+
+describe("copyValue", () => {
+	const TEXT_STRING = "Test text" as const
+
+	it("copies text to the clipboard", () => {
+		const textAreaMock: {
+			value: string
+			select: () => void
+			remove: () => void
+		} = {
+			value: "",
+			select: vi.fn(),
+			remove: vi.fn(),
+		}
+
+		document.createElement = vi.fn().mockReturnValue(textAreaMock)
+		document.body.appendChild = vi.fn().mockReturnValue(textAreaMock)
+
+		copyValue(TEXT_STRING)
+
+		expect(document.createElement).toHaveBeenCalledWith("textarea")
+		expect(document.body.appendChild).toHaveBeenCalled()
+		expect(document.execCommand).toHaveBeenCalledWith("copy", false)
+		expect(textAreaMock.value).toBe(TEXT_STRING)
+		expect(textAreaMock.select).toHaveBeenCalled()
+		expect(textAreaMock.remove).toHaveBeenCalled()
+	})
+})

package/clipboard.ts

@@ -0,0 +1,10 @@
+export const copyValue = (text: string): void => {
+	const input: HTMLTextAreaElement = document.createElement("textarea")
+
+	document.body.appendChild(input)
+	input.value = text
+	input.select()
+	document.execCommand("copy", false)
+
+	return input.remove()
+}

package/colors.spec.ts

@@ -0,0 +1,40 @@
+import { it, describe, expect } from "vitest"
+import { rgbToHex, hexToRgb, DEFAULT_PROFILE_RGB } from "./colors"
+
+describe("colors", () => {
+	describe("hexToRgb", () => {
+		it("converts hex to rgb", () => expect(hexToRgb("#0c2c78")).toEqual([12, 44, 120]))
+		it("converts hex without #", () => expect(hexToRgb("0c2c78")).toEqual([12, 44, 120]))
+		it("converts uppercase hex", () => expect(hexToRgb("#0C2C78")).toEqual([12, 44, 120]))
+		it("converts short hex", () => expect(hexToRgb("#fff")).toEqual([0, 15, 255]))
+		it("converts black", () => expect(hexToRgb("#000000")).toEqual([0, 0, 0]))
+		it("converts white", () => expect(hexToRgb("#ffffff")).toEqual([255, 255, 255]))
+		it("returns default for 0", () => expect(hexToRgb(0 as unknown as string)).toEqual(DEFAULT_PROFILE_RGB))
+		it("returns default for undefined", () => expect(hexToRgb(undefined)).toEqual(DEFAULT_PROFILE_RGB))
+		it("returns default for null", () => expect(hexToRgb(null)).toEqual(DEFAULT_PROFILE_RGB))
+		it("returns default for empty string", () => expect(hexToRgb("")).toEqual(DEFAULT_PROFILE_RGB))
+		it("returns default for invalid hex", () => expect(hexToRgb("gggggg")).toEqual([0, 0, 0]))
+		it("returns default for non-string", () => expect(hexToRgb(123 as unknown as string)).toEqual(DEFAULT_PROFILE_RGB))
+	})
+
+	describe("rgbToHex", () => {
+		it("converts rgb to hex", () => expect(rgbToHex(12, 44, 120)).toEqual("#0c2c78"))
+		it("converts string to hex", () =>
+			expect(rgbToHex("12" as unknown as number, "44" as unknown as number, "120" as unknown as number)).toEqual(
+				"#0c2c78",
+			))
+		it("converts null to hex", () => expect(rgbToHex(null as unknown as number, 44, 120)).toEqual("#002c78"))
+		it("returns undefined to hex", () => expect(rgbToHex(12, undefined as unknown as number, 120)).toEqual("#0cff78"))
+		it("returns FF for negative", () => expect(rgbToHex(-1, -12, 120)).toEqual("#ffff78"))
+		it("converts zero values", () => expect(rgbToHex(0, 0, 0)).toEqual("#000000"))
+		it("converts max values", () => expect(rgbToHex(255, 255, 255)).toEqual("#ffffff"))
+		it("returns FF for over 255", () => expect(rgbToHex(300, 256, 120)).toEqual("#ffff78"))
+		it("returns FF for invalid string", () => expect(rgbToHex("abc" as unknown as number, 44, 120)).toEqual("#ff2c78"))
+		it("handles fractional numbers", () =>
+			expect(rgbToHex(12.9, 44.1, 120.5)).toEqual("#c.e6666666666682c.19999999999a78.8"))
+		it("uses defaults when no params", () => expect(rgbToHex()).toEqual("#ffffff"))
+		it("handles mixed valid/invalid", () =>
+			expect(rgbToHex(12, "invalid" as unknown as number, 120)).toEqual("#0cff78"))
+		it("converts single digit to padded hex", () => expect(rgbToHex(1, 2, 3)).toEqual("#010203"))
+	})
+})

package/colors.ts

@@ -0,0 +1,33 @@
+type TypeRGB = [number, number, number]
+
+export const DEFAULT_PROFILE_RGB: TypeRGB = [199, 201, 209] as const
+
+export const hexToRgb = (hex?: string | null): TypeRGB => {
+	const isValid: boolean = !!hex && typeof hex === "string"
+
+	if (!isValid || !hex) return DEFAULT_PROFILE_RGB
+
+	hex = hex.replace(/^#/, "")
+
+	const bigint = parseInt(hex, 16)
+	const r: number = (bigint >> 16) & 255
+	const g: number = (bigint >> 8) & 255
+	const b: number = bigint & 255
+
+	return [r, g, b]
+}
+
+export const rgbToHex = (r: number | string = 255, g: number | string = 255, b: number | string = 255): string => {
+	const _toHex = (c: unknown): string => {
+		const value: number = Number(c)
+		const isInvalid: boolean = isNaN(value) || value < 0 || value > 255
+
+		if (isInvalid) return "ff"
+
+		const hex = value.toString(16)
+
+		return hex.length === 1 ? `0${hex}` : hex
+	}
+
+	return `#${_toHex(r)}${_toHex(g)}${_toHex(b)}`
+}

package/debounce.spec.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi } from "vitest"
+import { debounce } from "./debounce"
+import { sleep } from "./sleep"
+
+describe("debounce", () => {
+	it("calls the callback after the specified time", async () => {
+		const callback = vi.fn()
+		const debouncedFunction = debounce(callback, 50)
+
+		debouncedFunction()
+
+		await sleep(25)
+		expect(callback).not.toHaveBeenCalled()
+
+		await sleep(30)
+		expect(callback).toHaveBeenCalledTimes(1)
+	})
+
+	it("does not call the callback if the function is called again within the wait time", async () => {
+		const callback = vi.fn()
+		const debouncedFunction = debounce(callback, 50)
+
+		debouncedFunction()
+		await sleep(25)
+
+		debouncedFunction()
+		await sleep(25)
+
+		expect(callback).not.toHaveBeenCalled()
+
+		await sleep(30)
+		expect(callback).toHaveBeenCalledTimes(1)
+	})
+
+	it("preserves function arguments", async () => {
+		const callback = vi.fn()
+		const debouncedFunction = debounce(callback, 50)
+
+		debouncedFunction("arg1", "arg2", 123)
+
+		await sleep(60)
+		expect(callback).toHaveBeenCalledWith("arg1", "arg2", 123)
+	})
+
+	it("uses the latest arguments when called multiple times", async () => {
+		const callback = vi.fn()
+		const debouncedFunction = debounce(callback, 50)
+
+		debouncedFunction("first")
+		await sleep(25)
+
+		debouncedFunction("second")
+		await sleep(60)
+
+		expect(callback).toHaveBeenCalledTimes(1)
+		expect(callback).toHaveBeenCalledWith("second")
+	})
+
+	it("works with functions that have specific parameter types", async () => {
+		const callback = vi.fn((str: string, num: number) => str + num)
+		const debouncedFunction = debounce(callback, 50)
+
+		debouncedFunction("test", 42)
+
+		await sleep(60)
+		expect(callback).toHaveBeenCalledWith("test", 42)
+	})
+
+	it("works with functions that return values", async () => {
+		const callback = vi.fn((x: number) => x * 2)
+		const debouncedFunction = debounce(callback, 50)
+
+		debouncedFunction(5)
+
+		await sleep(60)
+		expect(callback).toHaveBeenCalledWith(5)
+	})
+
+	it("works with zero wait time", async () => {
+		const callback = vi.fn()
+		const debouncedFunction = debounce(callback, 0)
+
+		debouncedFunction()
+
+		await sleep(1)
+		expect(callback).toHaveBeenCalledTimes(1)
+	})
+
+	it("can be called after completion", async () => {
+		const callback = vi.fn()
+		const debouncedFunction = debounce(callback, 50)
+
+		debouncedFunction()
+		await sleep(60)
+		expect(callback).toHaveBeenCalledTimes(1)
+
+		debouncedFunction()
+		await sleep(60)
+		expect(callback).toHaveBeenCalledTimes(2)
+	})
+})

package/debounce.ts

@@ -0,0 +1,15 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const debounce = <T extends (...args: Array<any>) => any>(
+	callback: T,
+	wait: number,
+): ((...args: Parameters<T>) => void) => {
+	let timeoutId: ReturnType<typeof setTimeout>
+
+	return (...args: Parameters<T>): void => {
+		globalThis.clearTimeout(timeoutId)
+
+		timeoutId = globalThis.setTimeout(() => {
+			callback.apply(null, args)
+		}, wait)
+	}
+}

package/equals.spec.ts

@@ -0,0 +1,168 @@
+import { getIsEqual, getAreSetsEqual } from "./equals"
+import { describe, it, expect } from "vitest"
+
+describe("getIsEqual", () => {
+	it("primitives", () => {
+		expect(getIsEqual(1, 1)).toBe(true)
+		expect(getIsEqual("hello", "hello")).toBe(true)
+		expect(getIsEqual(" ", " ")).toBe(true)
+		expect(getIsEqual("❤️", "❤️")).toBe(true)
+		expect(getIsEqual(true, true)).toBe(true)
+		expect(getIsEqual(null, null)).toBe(true)
+		expect(getIsEqual(undefined, undefined)).toBe(true)
+		expect(getIsEqual(1, 2)).toBe(false)
+		expect(getIsEqual("hello", "world")).toBe(false)
+		expect(getIsEqual(true, false)).toBe(false)
+		expect(getIsEqual(null, undefined)).toBe(false)
+	})
+
+	it("arrays", () => {
+		expect(getIsEqual([], [])).toBe(true)
+		expect(getIsEqual([1, 2, 3], [1, 2, 3])).toBe(true)
+		expect(getIsEqual([1, [2, 3]], [1, [2, 3]])).toBe(true)
+		expect(getIsEqual([1, 2], [1, 2, 3])).toBe(false)
+		expect(getIsEqual([1, 2, 3], [1, 3, 2])).toBe(false)
+	})
+
+	it("objects", () => {
+		expect(getIsEqual({}, {})).toBe(true)
+		expect(getIsEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)
+		expect(getIsEqual({ a: { b: 2 } }, { a: { b: 2 } })).toBe(true)
+		expect(getIsEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true)
+		expect(getIsEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+		expect(getIsEqual({ a: 1 }, { a: 2 })).toBe(false)
+
+		const object1 = { a: 1, b: 2 }
+		expect(getIsEqual(object1, null)).toBeFalsy()
+		expect(getIsEqual(null, object1)).toBeFalsy()
+		expect(getIsEqual(undefined, undefined)).toBeTruthy()
+
+		const object3 = { a: 1, b: 2 }
+		const object4 = { b: 2, a: 1 }
+		expect(getIsEqual(object3, object4)).toBeTruthy()
+	})
+
+	it("dates", () => {
+		const date1 = new Date("2024-01-01")
+		const date2 = new Date("2024-01-01")
+		const date3 = new Date("2024-01-02")
+
+		expect(getIsEqual(date1, date2)).toBe(true)
+		expect(getIsEqual(date1, date3)).toBe(false)
+	})
+
+	it("sets", () => {
+		const basicSet1 = new Set(["hello", 2, 3])
+		const basicSet2 = new Set(["hello", 2, 3])
+		const basicSet3 = new Set(["hello", 2, "3"])
+
+		expect(getIsEqual(basicSet1, basicSet2)).toBe(true)
+		expect(getIsEqual(basicSet1, basicSet3)).toBe(false)
+
+		const objectSet1 = new Set([{ a: 1 }, { b: 2 }])
+		const objectSet2 = new Set([{ a: 1 }, { b: 2 }])
+		const objectSet3 = new Set([{ a: 1 }, { b: 3 }])
+
+		expect(getAreSetsEqual(objectSet1, objectSet2)).toBe(true)
+		expect(getAreSetsEqual(objectSet1, objectSet3)).toBe(false)
+
+		const nestedSet1 = new Set([{ a: { b: 2 } }, [1, 2, 3]])
+		const nestedSet2 = new Set([{ a: { b: 2 } }, [1, 2, 3]])
+		const nestedSet3 = new Set([{ a: { b: 3 } }, [1, 2, 3]])
+
+		expect(getAreSetsEqual(nestedSet1, nestedSet2)).toBe(true)
+		expect(getAreSetsEqual(nestedSet1, nestedSet3)).toBe(false)
+
+		const emptySet1 = new Set()
+		const emptySet2 = new Set()
+
+		expect(getAreSetsEqual(emptySet1, emptySet2)).toBe(true)
+	})
+
+	it("maps", () => {
+		const map1 = new Map([
+			["a", 1],
+			["b", 2],
+		])
+		const map2 = new Map([
+			["a", 1],
+			["b", 2],
+		])
+		const map3 = new Map([
+			["a", 1],
+			["b", 3],
+		])
+
+		expect(getIsEqual(map1, map2)).toBe(true)
+		expect(getIsEqual(map1, map3)).toBe(false)
+	})
+
+	it("circular references", () => {
+		const obj1: Record<string, unknown> = { a: 1 }
+		const obj2: Record<string, unknown> = { a: 1 }
+
+		obj1["self"] = obj1
+		obj2["self"] = obj2
+
+		expect(getIsEqual(obj1, obj2)).toBe(true)
+	})
+
+	it("circular arrays", () => {
+		const arr1: Array<unknown> = [1]
+		const arr2: Array<unknown> = [1]
+		arr1.push(arr1)
+		arr2.push(arr2)
+		expect(getIsEqual(arr1, arr2)).toBe(true)
+	})
+
+	it("symbols are unique", () => {
+		const symbol1 = Symbol("foo")
+		const symbol2 = Symbol("foo")
+
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		expect(getIsEqual(symbol1, symbol2 as any)).toBe(false)
+	})
+
+	it("bigint", () => {
+		expect(getIsEqual(42n, 42n)).toBe(true)
+		expect(getIsEqual(42n, 43n)).toBe(false)
+	})
+
+	it("regexps", () => {
+		const regex1 = /hello/gi
+		const regex2 = /hello/gi
+		const regex3 = /world/gi
+
+		expect(getIsEqual(regex1, regex2)).toBe(true)
+		expect(getIsEqual(regex1, regex3)).toBe(false)
+	})
+
+	it("errors", () => {
+		const error1 = new Error("test message")
+		const error2 = new Error("test message")
+		const error3 = new Error("different message")
+
+		// Errors with same message but different stack traces are not equal
+		expect(getIsEqual(error1, error2)).toBe(false)
+		expect(getIsEqual(error1, error3)).toBe(false)
+
+		// Same error instance is equal to itself
+		expect(getIsEqual(error1, error1)).toBe(true)
+	})
+
+	it("buffers", () => {
+		const buffer1 = Buffer.from("hello")
+		const buffer2 = Buffer.from("hello")
+		const buffer3 = Buffer.from("world")
+
+		expect(getIsEqual(buffer1, buffer2)).toBe(true)
+		expect(getIsEqual(buffer1, buffer3)).toBe(false)
+	})
+
+	it("duplicate array check branch", () => {
+		const arr1 = [1, 2, 3]
+		const arr2 = [1, 2, 3]
+
+		expect(getIsEqual(arr1, arr2)).toBe(true)
+	})
+})

package/equals.ts

@@ -0,0 +1,120 @@
+type FracturesPrimitive = string | number | boolean | null | undefined | bigint | symbol
+type FracturesComparable = FracturesPrimitive | object | Array<unknown> | Set<unknown> | Map<unknown, unknown>
+
+export const _getAreMapsEqual = <K, V>(
+	mapA: Map<K, V>,
+	mapB: Map<K, V>,
+	seen = new WeakMap<object, object>(),
+): boolean => {
+	if (mapA.size !== mapB.size) return false
+	if (mapA === mapB) return true
+
+	const entriesA = Array.from(mapA.entries())
+	const entriesB = new Map(mapB)
+
+	return entriesA.every(
+		([key, value]) =>
+			entriesB.has(key) && _getIsEqual(value as FracturesComparable, entriesB.get(key) as FracturesComparable, seen),
+	)
+}
+
+export const getAreDatesEqual = (a: Date, b: Date): boolean => a.getTime() === b.getTime()
+export const getAreRegExpsEqual = (a: RegExp, b: RegExp): boolean => a.toString() === b.toString()
+export const getAreErrorsEqual = (a: Error, b: Error): boolean =>
+	a.message === b.message && a.name === b.name && a.stack === b.stack
+export const getAreBuffersEqual = (a: Buffer, b: Buffer): boolean => a.length === b.length && Buffer.compare(a, b) === 0
+
+export const getAreSetsEqual = <T>(setA: Set<T>, setB: Set<T>): boolean => {
+	if (setA.size !== setB.size) return false
+	if (setA === setB) return true
+	if (setA.size === 0) return true
+
+	const arrA = Array.from(setA)
+	const arrB = Array.from(setB)
+	const matched = new Array(arrB.length).fill(false)
+
+	for (let i = 0; i < arrA.length; i++) {
+		let foundMatch = false
+
+		for (let j = 0; j < arrB.length; j++) {
+			if (!matched[j] && _getIsEqual(arrA[i] as FracturesComparable, arrB[j] as FracturesComparable)) {
+				matched[j] = true
+				foundMatch = true
+				break
+			}
+		}
+
+		if (!foundMatch) return false
+	}
+
+	return true
+}
+
+export const _getIsEqual = <T extends FracturesComparable>(
+	a: T,
+	b: T,
+	seen = new WeakMap<object, object>(),
+): boolean => {
+	if (a === b) return true
+	if (a === null || b === null) return a === b
+
+	if (typeof a !== "object" && typeof b !== "object") {
+		return a === b
+	}
+
+	if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+		return false
+	}
+
+	if (Object.is(a, b)) return true
+
+	const typeA = typeof a
+	const typeB = typeof b
+
+	if (typeA !== typeB) return false
+	if (typeA !== "object") return false
+
+	const seenA = seen.get(a as object)
+	if (seenA) return seenA === b
+
+	seen.set(a as object, b as object)
+
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false
+
+		for (let i = 0; i < a.length; i++) {
+			if (!_getIsEqual(a[i], b[i], seen)) return false
+		}
+		return true
+	}
+
+	if (a instanceof Map && b instanceof Map) return _getAreMapsEqual(a, b, seen)
+	if (a instanceof Set && b instanceof Set) return getAreSetsEqual(a, b)
+	if (a instanceof Date && b instanceof Date) return getAreDatesEqual(a, b)
+	if (a instanceof Error && b instanceof Error) return getAreErrorsEqual(a, b)
+	if (a instanceof RegExp && b instanceof RegExp) return getAreRegExpsEqual(a, b)
+	if (Buffer.isBuffer(a) && Buffer.isBuffer(b)) return getAreBuffersEqual(a, b)
+
+	const keysA = [...Object.keys(a as object), ...Object.getOwnPropertySymbols(a as object)]
+	const keysB = [...Object.keys(b as object), ...Object.getOwnPropertySymbols(b as object)]
+
+	if (keysA.length !== keysB.length) return false
+
+	return keysA.every(
+		(key) =>
+			Object.prototype.hasOwnProperty.call(b, key) &&
+			_getIsEqual(
+				(a as Record<string | symbol, unknown>)[key] as FracturesComparable,
+				(b as Record<string | symbol, unknown>)[key] as FracturesComparable,
+				seen,
+			),
+	)
+}
+
+export const getIsEqual = <T extends FracturesComparable>(a: T, b: T): boolean => {
+	return _getIsEqual(a, b)
+}
+
+export const getAreMapsEqual = <T extends FracturesComparable>(a: T, b: T): boolean => {
+	return _getAreMapsEqual(a as Map<unknown, unknown>, b as Map<unknown, unknown>)
+}

package/index.ts

@@ -0,0 +1,20 @@
+export { getClasses } from "./classnames"
+export { copyValue } from "./clipboard"
+export { hexToRgb, rgbToHex } from "./colors"
+export { debounce } from "./debounce"
+export {
+	getIsEqual,
+	getAreMapsEqual,
+	getAreSetsEqual,
+	getAreDatesEqual,
+	getAreErrorsEqual,
+	getAreRegExpsEqual,
+	getAreBuffersEqual,
+} from "./equals"
+export { sleep } from "./sleep"
+export { getSlug } from "./slug"
+export { removeMarkdown, removeNewlines, ellipsis } from "./strings"
+export { sanitizeText } from "./sanitize"
+export { throttle } from "./throttle"
+export { isUUID, getUUID } from "./uuid"
+export { validateUrl, validateEmail } from "./validations"

package/package.json

@@ -0,0 +1,14 @@
+{
+	"name": "@heliosgraphics/utils",
+	"version": "6.0.0-alpha.9",
+	"type": "module",
+	"author": "Chris Puska <chris@puska.org>",
+	"license": "MIT",
+	"private": false,
+	"description": "Universal Javascript Helpers",
+	"main": "index.ts",
+	"dependencies": {
+		"@types/node": "^24"
+	},
+	"devDependencies": {}
+}