@heliosgraphics/utils 6.0.0-alpha.10 → 6.0.0-alpha.13

package/strings.spec.ts

@@ -1,77 +0,0 @@
-import { it, describe, expect } from "vitest"
-import { removeMarkdown, removeNewlines, ellipsis } from "./strings"
-
-describe("strings", () => {
-	describe("removeMarkdown", () => {
-		it("removes a bold format", () => expect(removeMarkdown("a **bold** text")).toEqual("a bold text"))
-		it("removes a link but keeps the name", () =>
-			expect(removeMarkdown("a [link](https://x.com) hello")).toEqual("a link hello"))
-		it("removes a bold link", () =>
-			expect(removeMarkdown("a [bold **link**](https://x.com) hello")).toEqual("a bold link hello"))
-	})
-
-	describe("removeNewlines", () => {
-		it("removes no newline", () => expect(removeNewlines("first line same line")).toEqual("first line same line"))
-		it("removes newline", () =>
-			expect(removeNewlines("first line\n\n\nsecond line\n")).toEqual("first line second line"))
-		it("removes r newline", () =>
-			expect(removeNewlines("first line\r\n\nsecond line\n")).toEqual("first line second line"))
-		it("removes t newline", () => expect(removeNewlines("first line\tsecond line\n")).toEqual("first line second line"))
-		it("removes only a newline", () => expect(removeNewlines("\r")).toEqual(""))
-		it("removes nothing without newline", () => expect(removeNewlines("hey", undefined)).toEqual("hey"))
-		it("cuts string at the right position", () => expect(removeNewlines("ellipsis", 5)).toEqual("ellip"))
-		it("skips cutting if unnecessary", () => expect(removeNewlines("ellipsis", 20)).toEqual("ellipsis"))
-		it("returns empty string for null", () => expect(removeNewlines(null, 10)).toEqual(""))
-		it("returns empty string for undefined", () => expect(removeNewlines(undefined)).toEqual(""))
-		it("returns empty string for empty string", () => expect(removeNewlines("", 10)).toEqual(""))
-	})
-
-	describe("ellipsis", () => {
-		describe("end position (default)", () => {
-			it("truncates text at end with ellipsis", () => expect(ellipsis("Hello World", 8)).toEqual("Hello..."))
-			it("truncates longer text at end", () =>
-				expect(ellipsis("Lorem ipsum dolor sit amet", 15)).toEqual("Lorem ipsum ..."))
-			it("returns original text if shorter than max length", () => expect(ellipsis("Short", 10)).toEqual("Short"))
-			it("returns original text if equal to max length", () => expect(ellipsis("Exactly10!", 10)).toEqual("Exactly10!"))
-			it("handles single character with end position", () => expect(ellipsis("A", 5)).toEqual("A"))
-		})
-
-		describe("middle position", () => {
-			it("truncates text in middle with ellipsis", () =>
-				expect(ellipsis("Hello World", 8, "middle")).toEqual("He...rld"))
-			it("truncates longer text in middle", () =>
-				expect(ellipsis("Lorem ipsum dolor sit amet", 15, "middle")).toEqual("Lorem ...t amet"))
-			it("returns original text if shorter than max length", () =>
-				expect(ellipsis("Short", 10, "middle")).toEqual("Short"))
-			it("returns original text if equal to max length", () =>
-				expect(ellipsis("Exactly10!", 10, "middle")).toEqual("Exactly10!"))
-			it("handles odd length correctly", () => expect(ellipsis("Hello World", 7, "middle")).toEqual("He...ld"))
-			it("handles even length correctly", () => expect(ellipsis("Hello World", 8, "middle")).toEqual("He...rld"))
-		})
-
-		describe("edge cases", () => {
-			it("returns empty string for empty input", () => expect(ellipsis("", 5)).toEqual(""))
-			it("returns empty string for null input", () => expect(ellipsis(null as unknown as string, 5)).toEqual(""))
-			it("returns empty string for undefined input", () =>
-				expect(ellipsis(undefined as unknown as string, 5)).toEqual(""))
-			it("handles very small max length with end position", () => expect(ellipsis("Hello", 3)).toEqual(""))
-			it("handles very small max length with middle position", () => expect(ellipsis("Hello", 3, "middle")).toEqual(""))
-			it("handles max length of 4 with end position", () => expect(ellipsis("Hello", 4)).toEqual("H..."))
-			it("handles max length of 4 with middle position", () => expect(ellipsis("Hello", 4, "middle")).toEqual("...o"))
-		})
-
-		describe("emoji handling", () => {
-			it("truncates text with emojis at end", () => expect(ellipsis("Hello 👋 World 🌍", 12)).toEqual("Hello 👋 ..."))
-			it("truncates text with emojis in middle", () =>
-				expect(ellipsis("Hello 👋 World 🌍", 12, "middle")).toEqual("Hell...ld 🌍"))
-			it("preserves emojis when text is shorter than max length", () => expect(ellipsis("Hi 👋", 10)).toEqual("Hi 👋"))
-			it("handles text with basic emojis", () => expect(ellipsis("Hello world 😊", 10)).toEqual("Hello w..."))
-			it("demonstrates emoji splitting limitation", () => {
-				// Note: This function works with UTF-16 code units, not visual characters
-				// Complex emojis may be split incorrectly at boundaries
-				const result = ellipsis("👨‍💻 Work", 8)
-				expect(result.length).toBeLessThanOrEqual(8)
-			})
-		})
-	})
-})

package/throttle.spec.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect, vi } from "vitest"
-import { throttle } from "./throttle"
-import { sleep } from "./sleep"
-
-describe("throttle", () => {
-	it("executes callback once within throttle window", async () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 50)
-
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(1)
-
-		throttled()
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(1)
-
-		await sleep(60)
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(2)
-	})
-
-	it("executes immediately on first call", () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 50)
-
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(1)
-	})
-
-	it("preserves function arguments on first call", () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 50)
-
-		throttled("arg1", "arg2", 123)
-		expect(fn).toHaveBeenCalledWith("arg1", "arg2", 123)
-	})
-
-	it("ignores subsequent calls within throttle window", () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 50)
-
-		throttled("first")
-		expect(fn).toHaveBeenCalledWith("first")
-
-		throttled("second")
-		throttled("third")
-		expect(fn).toHaveBeenCalledTimes(1)
-		expect(fn).toHaveBeenCalledWith("first")
-	})
-
-	it("allows execution after throttle window expires", async () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 50)
-
-		throttled("first")
-		expect(fn).toHaveBeenCalledTimes(1)
-
-		await sleep(60)
-
-		throttled("second")
-		expect(fn).toHaveBeenCalledTimes(2)
-		expect(fn).toHaveBeenLastCalledWith("second")
-	})
-
-	it("works with functions that have specific parameter types", () => {
-		const fn = vi.fn((str: string, num: number) => str + num)
-		const throttled = throttle(fn, 50)
-
-		throttled("test", 42)
-		expect(fn).toHaveBeenCalledWith("test", 42)
-	})
-
-	it("works with functions that return values", () => {
-		const fn = vi.fn((x: number) => x * 2)
-		const throttled = throttle(fn, 50)
-
-		throttled(5)
-		expect(fn).toHaveBeenCalledWith(5)
-	})
-
-	it("handles rapid successive calls correctly", () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 50)
-
-		for (let i = 0; i < 10; i++) {
-			throttled(i)
-		}
-
-		expect(fn).toHaveBeenCalledTimes(1)
-		expect(fn).toHaveBeenCalledWith(0)
-	})
-
-	it("works with zero delay", async () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 0)
-
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(1)
-
-		await sleep(1)
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(2)
-	})
-
-	it("maintains separate throttle windows for different throttled functions", () => {
-		const fn1 = vi.fn()
-		const fn2 = vi.fn()
-		const throttled1 = throttle(fn1, 50)
-		const throttled2 = throttle(fn2, 50)
-
-		throttled1()
-		throttled2()
-
-		expect(fn1).toHaveBeenCalledTimes(1)
-		expect(fn2).toHaveBeenCalledTimes(1)
-
-		throttled1()
-		throttled2()
-
-		expect(fn1).toHaveBeenCalledTimes(1)
-		expect(fn2).toHaveBeenCalledTimes(1)
-	})
-
-	it("resets throttle window correctly", async () => {
-		const fn = vi.fn()
-		const throttled = throttle(fn, 50)
-
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(1)
-
-		await sleep(25)
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(1)
-
-		await sleep(30)
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(2)
-
-		throttled()
-		expect(fn).toHaveBeenCalledTimes(2)
-	})
-})

package/tsconfig.json

@@ -1,40 +0,0 @@
-{
-	"compilerOptions": {
-		"allowJs": false,
-		"baseUrl": ".",
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"incremental": true,
-		"isolatedModules": true,
-		"jsx": "preserve",
-		"lib": ["dom", "dom.iterable", "esnext"],
-		"module": "esnext",
-		"moduleResolution": "bundler",
-		"noEmit": true,
-		"noFallthroughCasesInSwitch": true,
-		"noImplicitAny": true,
-		"noImplicitOverride": true,
-		"noImplicitReturns": true,
-		"noImplicitThis": true,
-		"noPropertyAccessFromIndexSignature": true,
-		"noUncheckedIndexedAccess": true,
-		"noUnusedLocals": true,
-		"noUnusedParameters": true,
-		"exactOptionalPropertyTypes": true,
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"sourceMap": true,
-		"strict": true,
-		"strictBindCallApply": true,
-		"strictFunctionTypes": true,
-		"strictNullChecks": true,
-		"strictPropertyInitialization": true,
-		"target": "ES2022",
-		"useDefineForClassFields": true,
-		"verbatimModuleSyntax": false,
-		"types": ["node"]
-	},
-	"typeRoots": ["./node_modules/@types", "./types"],
-	"include": ["next-env.d.ts", ".next/types/**/*.ts", "**/*.ts", "**/*.tsx"],
-	"exclude": ["node_modules"]
-}

package/uuid.spec.ts

@@ -1,32 +0,0 @@
-import { it, describe, expect } from "vitest"
-import { getUUID, isUUID } from "./uuid"
-
-describe("validations", () => {
-	describe("getUUID", () => {
-		const UUID_1 = getUUID()
-		const UUID_1_IS_VALID = isUUID(UUID_1)
-		const UUID_2_STRING = "any-string"
-		const UUID_2 = getUUID(UUID_2_STRING)
-		const UUID_3 = getUUID()
-		const UUID_4 = getUUID()
-
-		it("returns a valid uuid", () => expect(UUID_1_IS_VALID).toEqual(true))
-		it("returns passed through", () => expect(UUID_2).toEqual(UUID_2_STRING))
-		it("returns different uuids on separate calls", () => expect(UUID_3).not.toEqual(UUID_4))
-	})
-
-	describe("isUUID", () => {
-		const UUID_3 = getUUID()
-		const UUID_3_IS_VALID = isUUID(UUID_3)
-		const UUID_4_IS_VALID = isUUID("101bfe56-8c16-4f94-9b45-759ea5e67cea")
-
-		it("validates a random uuid", () => expect(UUID_3_IS_VALID).toEqual(true))
-		it("validates a static uuid", () => expect(UUID_4_IS_VALID).toEqual(true))
-
-		const UUID_5_IS_VALID = isUUID("")
-		const UUID_6_IS_VALID = isUUID(undefined)
-
-		it("catches empty string", () => expect(UUID_5_IS_VALID).toEqual(false))
-		it("catches undefined", () => expect(UUID_6_IS_VALID).toEqual(false))
-	})
-})

package/validations.spec.ts

@@ -1,26 +0,0 @@
-import { validateUrl, validateEmail } from "./validations"
-import { it, describe, expect } from "vitest"
-
-describe("validations", () => {
-	describe("validateEmail", () => {
-		it("validates email", () => expect(validateEmail("x@x.com")).toEqual(true))
-		it("validates email with +", () => expect(validateEmail("x+x@x.com")).toEqual(true))
-		it("validates email with long tld", () => expect(validateEmail("0@helios.graphics")).toEqual(true))
-		it("catches long invalid string", () => expect(validateEmail("@space.city")).toEqual(false))
-		it("catches empty string", () => expect(validateEmail("")).toEqual(false))
-		it("catches undefined", () => expect(validateEmail(undefined)).toEqual(false))
-		it("catches multi @", () => expect(validateEmail("x@@x.com")).toEqual(false))
-		it("catches a weird one", () => expect(validateEmail("x@@@x.com@/@x.com")).toEqual(false))
-	})
-
-	describe("validateHttpUrl", () => {
-		it("validates url", () => expect(validateUrl("https://x.com")).toEqual(true))
-		it("validates url with long tld", () => expect(validateUrl("https://lorem-ipsum.graphics")).toEqual(true))
-		it("validates url with double subdomain", () => expect(validateUrl("https://0.x.x.com")).toEqual(true))
-		it("catches ftp", () => expect(validateUrl("ftp://x.com")).toEqual(false))
-		it("catches string containing url", () => expect(validateUrl("lorem ipsum https://x.com")).toEqual(false))
-		it("catches unsafe http", () => expect(validateUrl("http://x.com")).toEqual(false))
-		it("catches empty string", () => expect(validateUrl("")).toEqual(false))
-		it("catches undefined", () => expect(validateUrl(undefined)).toEqual(false))
-	})
-})