refactor(packages/string): ♻️ Fix validators

Author: xeho91

packages/string/source/char/char.test.ts

@@ -96,12 +96,9 @@ describe("isSingleChar(input)", () => {
 describe("validateSingleChar(char)", () => {
 	testInvalidCharInput(validateSingleChar);
 
-	it(returns({ what: "String", value: "<single char>" }).on(`passed single chars`).samples(SINGLE_CHARS), () => {
+	it(returns().on(`passed single chars`).samples(SINGLE_CHARS), () => {
 		for (const singleChar of SINGLE_CHARS) {
-			const validatedChar = validateSingleChar(singleChar);
-
-			expect(validatedChar).toStrictEqual(singleChar);
-			expect(validatedChar).toBeTypeOf("string");
+			expect(() => validateSingleChar(singleChar)).not.toThrowError();
 		}
 	});
 });
@@ -113,12 +110,9 @@ describe("validateCharType(type)", () => {
 		expect(() => validateCharType(sample)).toThrowError(ZodError);
 	});
 
-	it(returns({ what: "String", value: "<valid char type>" }).on(`valid char types`).samples(CHAR_TYPES), () => {
+	it(returns().on(`valid char types`).samples(CHAR_TYPES), () => {
 		for (const type of CHAR_TYPES) {
-			const validatedCharType = validateCharType(type);
-
-			expect(validatedCharType).toBeTypeOf("string");
-			expect(validatedCharType).toStrictEqual(type);
+			expect(() => validateCharType(type)).not.toThrowError();
 		}
 	});
 });

packages/string/source/char/char.ts

@@ -1,8 +1,9 @@
 import { charIn, createRegExp, type RegExpOptions, setRegExpFlags } from "@terminal-nerds/snippets-regexp/creator";
+import { STRING_SCHEMA } from "@terminal-nerds/snippets-type";
 import type { Join, PascalCase } from "type-fest";
 import { z } from "zod";
 
-import { validateString } from "../main.js";
+import { validateString } from "../schema/schema.js";
 
 export const CHAR_TYPES = ["latin", "number", "special"] as const;
 export type CharType = (typeof CHAR_TYPES)[number];
@@ -47,7 +48,7 @@ export const NON_LATIN_CHARS = [...NUMBER_CHARS, ...SPECIAL_CHARS] as const;
 export const NON_NUMBER_CHARS = [...LATIN_CHARS, ...SPECIAL_CHARS] as const;
 export const NON_SPECIAL_CHARS = [...LATIN_CHARS, ...NUMBER_CHARS] as const;
 
-export const CHAR_SCHEMA = z.string().length(1, "This is supposed to be a single char");
+export const CHAR_SCHEMA = STRING_SCHEMA.length(1, "This is supposed to be a single char");
 export const CHAR_TYPE_SCHEMA = z.enum(CHAR_TYPES);
 
 export const LATIN_CHAR_SCHEMA = z.enum(LOWER_CASED_LATIN_CHARS);
@@ -62,16 +63,16 @@ export const CHARS_SCHEMAS = {
 } as const;
 /* c8 ignore stop */
 
+export function validateSingleChar(char: string): asserts char is SingleChar {
+	CHAR_SCHEMA.parse(char);
+}
+
 export function isSingleChar(input: string): input is SingleChar {
 	validateString(input);
 
 	return CHAR_SCHEMA.safeParse(input).success;
 }
 
-export function validateSingleChar(char: string): string {
-	return CHAR_SCHEMA.parse(char);
-}
-
 export function getJoinedChars<T extends readonly string[]>(chars: T) {
 	return chars.join("") as Join<T, "">;
 }
@@ -80,8 +81,8 @@ export interface CharOptions<T extends CharType> extends RegExpOptions {
 	type: T;
 }
 
-export function validateCharType(type: string): CharType {
-	return CHAR_TYPE_SCHEMA.parse(type);
+export function validateCharType(type: string): asserts type is CharType {
+	CHAR_TYPE_SCHEMA.parse(type);
 }
 
 export function isValidCharType(type: string): type is CharType {

packages/string/source/schema/schema.ts

@@ -1,12 +1,12 @@
-import { STRING_SCHEMA, validatePrimitive } from "@terminal-nerds/snippets-type/primitive";
+import { isPrimitive, validatePrimitive } from "@terminal-nerds/snippets-type/primitive";
 import { z } from "zod";
 
 export function validateString(value: unknown): asserts value is string {
 	return validatePrimitive(value, "string");
 }
 
 export function isString(value: unknown): value is string {
-	return STRING_SCHEMA.safeParse(value).success;
+	return isPrimitive(value, "string");
 }
 
 export type EmptyString = "";

packages/string/source/word/word.ts

@@ -11,7 +11,7 @@ export function reverseString<T extends string>(input: T): ReversedString<T> {
 	return [...input].reverse().join("") as ReversedString<T>;
 }
 
-/** Palindrome - {@link https://en.wikipedia.org/wiki/Palindrome} */
+/** @see {@link https://en.wikipedia.org/wiki/Palindrome} Palindrome */
 export function isPalindrome(input: string): boolean {
 	return reverseString(input) === input;
 }