trim string before checking length and match

src/string.ts

@@ -23,15 +23,16 @@ const stringRuntype = setupInternalRuntype<string>(
  *
  * Options:
  *
+ *   trim .. when true, remove leading and trailing spaces from the string
+ *           trimming is applied before the optional length and regex checks
  *   minLength .. reject strings that are shorter than that
  *   maxLength .. reject strings that are longer than that
- *   trim .. when true, remove leading and trailing spaces from the string
  *   match .. reject strings that do not match against provided RegExp
  */
 export function string(options?: {
+  trim?: boolean
   minLength?: number
   maxLength?: number
-  trim?: boolean
   match?: RegExp
 }): Runtype<string> {
   if (!options) {
@@ -44,12 +45,14 @@ export function string(options?: {
 
   return setupInternalRuntype(
     (v, failOrThrow) => {
-      const s: string = (stringRuntype as InternalRuntype<any>)(v, failOrThrow)
+      const r: string = (stringRuntype as InternalRuntype<any>)(v, failOrThrow)
 
-      if (isFail(s)) {
-        return propagateFail(failOrThrow, s, v)
+      if (isFail(r)) {
+        return propagateFail(failOrThrow, r, v)
       }
 
+      const s = trim ? r.trim() : r
+
       if (minLength !== undefined && s.length < minLength) {
         return createFail(
           failOrThrow,
@@ -74,7 +77,7 @@ export function string(options?: {
         )
       }
 
-      return trim ? s.trim() : s
+      return s
     },
     { isPure },
   )

test/nonStrict.test.ts

@@ -129,7 +129,7 @@ describe('nonStrict', () => {
     })
   })
 
-  // same as sloppyRecord
+  // same as the former sloppyRecord test
   it('ignores object attributes', () => {
     const runType = st.nonStrict(
       st.record({

test/string.test.ts

@@ -1,4 +1,9 @@
-import { expectAcceptValuesPure, expectRejectValues, st } from './helpers'
+import {
+  expectAcceptValuesImpure,
+  expectAcceptValuesPure,
+  expectRejectValues,
+  st,
+} from './helpers'
 
 describe('string', () => {
   it('accepts strings', () => {
@@ -54,6 +59,44 @@ describe('string', () => {
     expect(rt('foO')).toEqual('foO')
   })
 
+  it('trims before it checks the string minLength', () => {
+    const rt = st.string({ trim: true, minLength: 1 })
+
+    expect(rt('a')).toEqual('a')
+    expectAcceptValuesImpure(
+      rt,
+      [
+        [' a', 'a'],
+        [' a   ', 'a'],
+        [' aa', 'aa'],
+        ['   a a ', 'a a'],
+      ],
+      true,
+    )
+
+    expectRejectValues(rt, ['       ', '  ', ' ', '', 0, []])
+  })
+
+  it('trims before it checks the string maxLength', () => {
+    const rt = st.string({ trim: true, maxLength: 3 })
+
+    expect(rt('abc')).toEqual('abc')
+    expectAcceptValuesImpure(
+      rt,
+      [
+        [' abc', 'abc'],
+        ['abc   ', 'abc'],
+        ['   a c ', 'a c'],
+        [' ', ''],
+        ['        ', ''],
+        ['a ', 'a'],
+      ],
+      true,
+    )
+
+    expectRejectValues(rt, ['abcd', 'abcd ', '  abcd   ', 'a  d ', 0, []])
+  })
+
   it('rejects non-strings', () => {
     expectRejectValues(
       st.string(),
@@ -73,4 +116,8 @@ describe('string', () => {
       'expected the string to match /^[0-9a-f]{8}$/',
     )
   })
+
+  it('trims before applying match', () => {
+    const rt = st.string({ match: /^[0-9a-f]{8}$/ })
+  })
 })