allow non-zero-prefixed decimals in string.numeric (#1333)

Author: chvanam

ark/schema/__tests__/morphs.test.ts

@@ -15,7 +15,7 @@ contextualize(() => {
 		attest(parseNumber.in.json).snap({
 			domain: "string",
 			pattern: [
-				"^(?:(?!^-0\\.?0*$)(?:-?(?:(?:0|[1-9]\\d*)(?:\\.\\d*[1-9])?)|\\.\\d*[1-9]?))$"
+				"^(?:(?!^-0\\.?0*$)(?:-?(?:(?:0|[1-9]\\d*)(?:\\.\\d*[1-9])?)?))$"
 			],
 			meta: "a well-formed numeric string"
 		})

ark/type/__tests__/keywords/parse.test.ts

@@ -5,6 +5,7 @@ contextualize(() => {
 	it("number", () => {
 		const parseNum = type("string.numeric.parse")
 		attest(parseNum("5")).equals(5)
+		attest(parseNum(".5")).equals(0.5)
 		attest(parseNum("5.5")).equals(5.5)
 		attest(parseNum("five").toString()).snap(
 			'must be a well-formed numeric string (was "five")'

ark/type/__tests__/pipe.test.ts

@@ -780,7 +780,7 @@ contextualize(() => {
 >`)
 
 		attest(t.expression).snap(
-			"{ l: 1, n: (In: string /^(?:(?!^-0\\.?0*$)(?:-?(?:(?:0|[1-9]\\d*)(?:\\.\\d+)?)?))$/) => Out<number> } | { n: (In: string /^(?:(?!^-0\\.?0*$)(?:-?(?:(?:0|[1-9]\\d*)(?:\\.\\d+)?)?))$/) => Out<number>, r: 1 }"
+			"{ l: 1, n: (In: string /^(?:(?!^-0\\.?0*$)(?:-?(?:(?:0|[1-9]\\d*)(?:\\.\\d+)?)|\\.\\d+?))$/) => Out<number> } | { n: (In: string /^(?:(?!^-0\\.?0*$)(?:-?(?:(?:0|[1-9]\\d*)(?:\\.\\d+)?)|\\.\\d+?))$/) => Out<number>, r: 1 }"
 		)
 		attest(t({ l: 1, n: "234" })).snap({ l: 1, n: 234 })
 		attest(t({ r: 1, n: "234" })).snap({ r: 1, n: 234 })

ark/util/__tests__/numbers.test.ts

@@ -1,5 +1,5 @@
 import { attest, contextualize } from "@ark/attest"
-import { nearestFloat } from "@ark/util"
+import { isNumericString, isWellFormedNumber, nearestFloat } from "@ark/util"
 
 contextualize(() => {
 	describe("nearestFloat", () => {
@@ -25,4 +25,45 @@ contextualize(() => {
 			attest(nearestFloat(-5555555555555555, "-")).equals(-5555555555555556)
 		})
 	})
+
+	describe("number matchers", () => {
+		it("wellFormedNumberMatcher rejects decimal-only numbers", () => {
+			attest(isWellFormedNumber(".5")).equals(false)
+			attest(isWellFormedNumber("0.5")).equals(true)
+		})
+
+		it("numericStringMatcher accepts decimal-only numbers", () => {
+			attest(isNumericString(".5")).equals(true)
+			attest(isNumericString("0.5")).equals(true)
+		})
+
+		it("wellFormedNumberMatcher rejects trailing zeros in decimals", () => {
+			attest(isWellFormedNumber("0.10")).equals(false)
+			attest(isWellFormedNumber("0.1")).equals(true)
+		})
+
+		it("numericStringMatcher accepts trailing zeros in decimals", () => {
+			attest(isNumericString("0.10")).equals(true)
+			attest(isNumericString("0.1")).equals(true)
+		})
+
+		it("both matchers reject negative zero", () => {
+			attest(isWellFormedNumber("-0")).equals(false)
+			attest(isNumericString("-0")).equals(false)
+		})
+
+		it("both matchers accept valid integers", () => {
+			attest(isWellFormedNumber("123")).equals(true)
+			attest(isNumericString("123")).equals(true)
+			attest(isWellFormedNumber("-123")).equals(true)
+			attest(isNumericString("-123")).equals(true)
+		})
+
+		it("both matchers accept valid decimals", () => {
+			attest(isWellFormedNumber("123.456")).equals(true)
+			attest(isNumericString("123.456")).equals(true)
+			attest(isWellFormedNumber("-123.456")).equals(true)
+			attest(isNumericString("-123.456")).equals(true)
+		})
+	})
 })

ark/util/numbers.ts

@@ -13,7 +13,7 @@ export type NonNegativeIntegerLiteral<n extends bigint = bigint> =
 	| `${Digit}`
 	| (`${Exclude<Digit, 0>}${string}` & `${n}`)
 
-/**
+/*
  * The goal of the number literal and bigint literal regular expressions is to:
  *
  *   1. Ensure definitions form a bijection with the values they represent.
@@ -42,7 +42,7 @@ const createNumberMatcher = (opts: CreateNumberMatcherOptions) =>
 							RegexPatterns.nonCapturingGroup(opts.decimalPattern) +
 							"?"
 					) +
-					(opts.allowDecimalOnly ? "" : "|" + opts.decimalPattern) +
+					(opts.allowDecimalOnly ? "|" + opts.decimalPattern : "") +
 					"?"
 			)
 	)
@@ -73,6 +73,9 @@ export const numericStringMatcher: RegExp = createNumberMatcher({
 	allowDecimalOnly: true
 })
 
+export const isNumericString =
+	numericStringMatcher.test.bind(numericStringMatcher)
+
 export const numberLikeMatcher = /^-?\d*\.?\d*$/
 const isNumberLike = (s: string) => s.length !== 0 && numberLikeMatcher.test(s)