Add nonempty refinement (ianstormtaylor#946)

* feat: create not empty refinement

* docs: add not empty to refinements docs

* refactor: rename `notEmpty` to `nonempty`

Co-authored-by: Allan Juan <[email protected]>

Author: ifiokjr

docs/reference/refinements.md

@@ -18,6 +18,20 @@ empty(array())
 
 > 🤖 Technically this is the same as using [`size`](#size) of zero, but "empty" feels slightly nicer and will give a slightly easier to read error.
 
+### `max`
+
+```ts
+max(number(), 0)
+```
+
+```txt
+-1
+```
+
+`max` enforces that a `number` struct is less than a threshold.
+
+> 🤖 If you need an exclusive maxmimum you can pass `{ exclusive: true }` as the third argument, like `max(number(), 0, { exclusive: true })` for negative numbers.
+
 ### `min`
 
 ```ts
@@ -32,19 +46,14 @@ min(number(), 9000)
 
 > 🤖 If you need an exclusive minimum you can pass `{ exclusive: true }` as the third argument, like `min(number(), 0, { exclusive: true })` for positive numbers.
 
-### `max`
+### `nonempty`
 
 ```ts
-max(number(), 0)
+nonempty(string())
+nonempty(array())
 ```
 
-```txt
--1
-```
-
-`max` enforces that a `number` struct is less than a threshold.
-
-> 🤖 If you need an exclusive maxmimum you can pass `{ exclusive: true }` as the third argument, like `max(number(), 0, { exclusive: true })` for negative numbers.
+`nonempty` enforces that a string, array, map, or set is not empty. This does the opposite of `empty`.
 
 ### `pattern`
 

src/structs/refinements.ts

@@ -9,24 +9,23 @@ export function empty<
   T extends string | any[] | Map<any, any> | Set<any>,
   S extends any
 >(struct: Struct<T, S>): Struct<T, S> {
-  const expected = `Expected an empty ${struct.type}`
-
   return refine(struct, 'empty', (value) => {
-    if (value instanceof Map || value instanceof Set) {
-      const { size } = value
-      return (
-        size === 0 || `${expected} but received one with a size of \`${size}\``
-      )
-    } else {
-      const { length } = value as string | any[]
-      return (
-        length === 0 ||
-        `${expected} but received one with a length of \`${length}\``
-      )
-    }
+    const size = getSize(value)
+    return (
+      size === 0 ||
+      `Expected an empty ${struct.type} but received one with a size of \`${size}\``
+    )
   })
 }
 
+function getSize(value: string | any[] | Map<any, any> | Set<any>): number {
+  if (value instanceof Map || value instanceof Set) {
+    return value.size
+  } else {
+    return value.length
+  }
+}
+
 /**
  * Ensure that a number or date is below a threshold.
  */
@@ -70,6 +69,23 @@ export function min<T extends number | Date, S extends any>(
           }${threshold} but received \`${value}\``
   })
 }
+
+/**
+ * Ensure that a string, array, map or set is not empty.
+ */
+
+export function nonempty<
+  T extends string | any[] | Map<any, any> | Set<any>,
+  S extends any
+>(struct: Struct<T, S>): Struct<T, S> {
+  return refine(struct, 'nonempty', (value) => {
+    const size = getSize(value)
+    return (
+      size > 0 || `Expected a nonempty ${struct.type} but received an empty one`
+    )
+  })
+}
+
 /**
  * Ensure that a string matches a regular expression.
  */

test/typings/nonempty.ts

@@ -0,0 +1,22 @@
+import { assert, nonempty, string, array, map, set } from '../../lib'
+import { test } from '..'
+
+test<string>((x) => {
+  assert(x, nonempty(string()))
+  return x
+})
+
+test<Array<unknown>>((x) => {
+  assert(x, nonempty(array()))
+  return x
+})
+
+test<Set<unknown>>((x) => {
+  assert(x, nonempty(set()))
+  return x
+})
+
+test<Map<unknown, unknown>>((x) => {
+  assert(x, nonempty(map()))
+  return x
+})