Proposal: z.number().float()

[xeho91]

What?

A way to validate if the provided number is a float (double) one.

Example:

const FLOAT_NUMBER_SCHEMA = z.number().float();

---

Why?

We already have one which checks if it is an integer:

const INTEGER_NUMBER_SCHEMA = z.number().integer();

And in my project, I have a case where I can only accept double numbers.
So far, I can do it with native functions:

function isFloat(value: number): boolean {
    return Number.isFinite(value) && !Number.isInteger(value);
}

I believe it would be intuitive to add it to zod.

I'd like to know if this proposal would be accepted, before I could volunteer myself for doing a PR for this one.

[JacobWeisenburger]

numbers in javascript are floats by default.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number

[xeho91]

I am aware.

However, to my knowledge, I don't have a way of using zod to build a schema for numbers which are not:

• ❌ integers - AFAIK, there's no way to negate z.number().integer(),
• ✔️ infinite - possible via z.number().finite()

[JacobWeisenburger]

I could be wrong, but I'm pretty sure that all integers are floats, but not all floats are integers. So saying you don't want integers, is cutting out a huge amount of valid floats.

[xeho91]

You're not wrong. Now, I feel stupid that I brought it.

Perhaps it needs a different name, such as noninteger()? 🤔

[JacobWeisenburger]

I think a better proposal for a new feature would be .not(). Because that would serve many more use cases than just this one.

[xeho91]

I agree, the .not() would be very simple to use, especially in this case!

[JacobWeisenburger]

Is this what you are looking for?

const schema = z.number()
    .refine( n => !z.number().int().safeParse( n ).success, 'should not be integer' )

console.log( schema.parse( 42.42 ) ) // 42.42

const result = schema.safeParse( 42 )
!result.success && console.log( result.error.issues )
// [ { code: 'custom', message: 'should not be integer', path: [] } ]

If you found my answer satisfactory, please consider supporting me. Even a small amount is greatly appreciated. Thanks friend! 🙏
https://github.com/sponsors/JacobWeisenburger

[xeho91]

Close!

It didn't consider the infinite numbers, so I tweaked it slightly.

There's the full sample:

import type { Float } from "type-fest/source/numeric";
import { z } from "zod";

const FLOAT_NUMBER_SCHEMA = z.number().refine((n) => {
    return !z.number().int().safeParse(n).success && z.number().finite().safeParse(n).success;
}, "should not be an integer");

export type { Float } from "type-fest/source/numeric";

export function validateFloatNumber<N extends number>(value: N): asserts value is Float<N> {
    FLOAT_NUMBER_SCHEMA.parse(value);
}

export function isFloatNumber<N extends number>(value: N): value is Float<N> {
    return FLOAT_NUMBER_SCHEMA.safeParse(value).success;
}

And the test file for reference:

import { describe, it } from "vitest";
import { ZodError } from "zod";

import { isFloatNumber, validateFloatNumber } from "./float.ts";

const SAMPLE_INTEGER = 1337;
const SAMPLE_FLOAT = 1.234;

describe("validateFloatNumber(value)", () => {
    it(throws(ZodError).on(`sample integer number`).sample(SAMPLE_INTEGER), ( { expect }) => {
        expect(() => validateFloatNumber(SAMPLE_INTEGER)).toThrowError(ZodError);
    });

    it(throws(ZodError).on(`infinity values`).sample(`Infinity`), ( { expect }) => {
        expect(() => validateFloatNumber(Number.NEGATIVE_INFINITY)).toThrowError(ZodError);
        expect(() => validateFloatNumber(Number.POSITIVE_INFINITY)).toThrowError(ZodError);
    });
    
    it(returns().on(`sample float number`).sample(SAMPLE_FLOAT), ( { expect }) => {
        expect(() => validateFloatNumber(SAMPLE_FLOAT)).not.toThrowError(ZodError);
    });
});

describe("isFloatNumber(value)", () => {
    it(returns(false).on(`sample integer number`).sample(SAMPLE_INTEGER), ( { expect }) => {
        expect(isFloatNumber(SAMPLE_INTEGER)).toBe(false);
    });

    it(returns(false).on(`passed Infinity`).sample(`Infinity`), ( { expect }) => {
        expect(isFloatNumber(Number.NEGATIVE_INFINITY)).toBe(false);
        expect(isFloatNumber(Number.POSITIVE_INFINITY)).toBe(false);
    });
    
    it(returns(true).on(`sample float number`).sample(SAMPLE_FLOAT), ( { expect }) => {
        expect(isFloatNumber(SAMPLE_FLOAT)).toBe(true);
    });
});

---

I am very grateful for pointing me in the right direction. I am going to sponsor you. Thanks! ❤️
It might be a little since I'm struggling to get a job for a while, but once I get a stable income, I'll do more to help open-source heroes like you.

PS. Just a suggestion. You might consider getting yourself a Twitter account (I know is evil, and the CEO is satan or whatever), so I can help spread the word about you.

[JacobWeisenburger]

I am very grateful for pointing me in the right direction. I am going to sponsor you. Thanks! ❤️ It might be a little since I'm struggling to get a job for a while, but once I get a stable income, I'll do more to help open-source heroes like you.

PS. Just a suggestion. You might consider getting yourself a Twitter account (I know is evil, and the CEO is satan or whatever), so I can help spread the word about you.

Thanks so much 🙌 . I'll look into doing that.

[JacobWeisenburger]

I have made a twitter: https://twitter.com/JakeWeisDev
Thanks for the idea and your help with spreading the word about me.

[Toufiquer]

This is working for me,

export const newItemSchema = z.object({
  price: z
    .preprocess(
      (a) => parseFloat(z.string().parse(a)),
      z.number({
        invalid_type_error: "Price must be Number",
      })
    )
    .optional(),
})

It accepts both Int and float

[JacobWeisenburger]

Is this what you are looking for?

const schema = z.number().or( z.string() ).pipe( z.coerce.number() ).optional()
console.log( schema.safeParse( 42 ).success ) // true
console.log( schema.safeParse( '42' ).success ) // true
console.log( schema.safeParse( 42.42 ).success ) // true
console.log( schema.safeParse( '42.42' ).success ) // true

If you found my answer satisfactory, please consider supporting me. Even a small amount is greatly appreciated. Thanks friend! 🙏
https://github.com/sponsors/JacobWeisenburger

[jonashofmans97]

export const floatNumber = (min?: number, max?: number) =>
  z
    .string()
    .transform((value) =>
      max && Number(value) > max
        ? max
        : min && Number(value) < min
        ? min
        : value === ''
        ? ''
        : Number(value)
    )
    .refine((value) => !isNaN(Number(value)), {
      message: 'invalid',
    })
    .refine((value) => value !== '', {
      message: 'required',
    })
    .refine((value) => (max ? Number(value) <= max : true), {
      message: 'tooBig',
    })
    .refine((value) => (min ? Number(value) >= min : true), {
      message: 'tooSmall',
    });

Then use in your schema as lat_seconds: floatNumber(0, 59.999)

This schema in combination with a number input that only allows number and "E" will result in validation that accepts both integers and floats.

It will fail validation on

• empty field
• invalid number
• min and max

If you type a number that is higher than your max value, it will change the value to the max onBlur. Same for min