fast-json-stringify 4.0.0 → 4.1.0

package/README.md

@@ -62,6 +62,8 @@ compile-json-stringify date format x 1,086,187 ops/sec ±0.16% (99 runs sampled)
  - <a href="#nullable">`Nullable`</a>
  - <a href="#largearrays">`Large Arrays`</a>
 - <a href="#security">`Security Notice`</a>
+- <a href="#debug">`Debug Mode`</a>
+- <a href="#standalone">`Standalone Mode`</a>
 - <a href="#acknowledgements">`Acknowledgements`</a>
 - <a href="#license">`License`</a>
 
@@ -663,13 +665,37 @@ const debugCompiled = fastJson({
       type: 'string'
     }
   }
-}, { debugMode: true })
+}, { mode: 'debug' })
 
-console.log(debugCompiled) // it is an array of functions that can create your `stringify` function
-console.log(debugCompiled.toString()) // print a "ready to read" string function, you can save it to a file
+console.log(debugCompiled) // it is a object contain code, ajv instance
+const rawString = debugCompiled.code // it is the generated code
+console.log(rawString) 
 
-const rawString = debugCompiled.toString()
-const stringify = fastJson.restore(rawString) // use the generated string to get back the `stringify` function
+const stringify = fastJson.restore(debugCompiled) // use the generated string to get back the `stringify` function
+console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"Foo"}'
+```
+
+<a name="standalone"></a>
+### Standalone Mode
+
+The standalone mode is used to compile the code that can be directly run by `node`
+itself. You need to install `fast-json-stringify`, `ajv`, `fast-uri` and `ajv-formats`
+in order to let the standalone code works.
+
+```js
+const fs = require('fs')
+const code = fastJson({
+  title: 'default string',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    }
+  }
+}, { mode: 'standalone' })
+
+fs.writeFileSync('stringify.js', code)
+const stringify = require('stringify.js')
 console.log(stringify({ firstName: 'Foo', surname: 'bar' })) // '{"firstName":"Foo"}'
 ```
 

package/ajv.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const Ajv = require('ajv')
+const fastUri = require('fast-uri')
+const ajvFormats = require('ajv-formats')
+
+module.exports = buildAjv
+
+function buildAjv (options) {
+  const ajvInstance = new Ajv({ ...options, strictSchema: false, uriResolver: fastUri })
+  ajvFormats(ajvInstance)
+
+  const validateDateTimeFormat = ajvFormats.get('date-time').validate
+  const validateDateFormat = ajvFormats.get('date').validate
+  const validateTimeFormat = ajvFormats.get('time').validate
+
+  ajvInstance.addKeyword({
+    keyword: 'fjs_date_type',
+    validate: (schema, date) => {
+      if (date instanceof Date) {
+        return true
+      }
+      if (schema === 'date-time') {
+        return validateDateTimeFormat(date)
+      }
+      if (schema === 'date') {
+        return validateDateFormat(date)
+      }
+      if (schema === 'time') {
+        return validateTimeFormat(date)
+      }
+      return false
+    }
+  })
+
+  return ajvInstance
+}

package/index.js

@@ -2,15 +2,14 @@
 
 /* eslint no-prototype-builtins: 0 */
 
-const Ajv = require('ajv')
-const fastUri = require('fast-uri')
-const ajvFormats = require('ajv-formats')
 const merge = require('deepmerge')
 const clone = require('rfdc')({ proto: true })
 const fjsCloned = Symbol('fast-json-stringify.cloned')
 const { randomUUID } = require('crypto')
 
 const validate = require('./schema-validator')
+const Serializer = require('./serializer')
+const buildAjv = require('./ajv')
 
 let largeArraySize = 2e4
 let stringSimilarity = null
@@ -55,206 +54,17 @@ const objectReferenceSerializersMap = new Map()
 const schemaReferenceMap = new Map()
 
 let ajvInstance = null
-
-class Serializer {
-  constructor (options = {}) {
-    switch (options.rounding) {
-      case 'floor':
-        this.parseInteger = Math.floor
-        break
-      case 'ceil':
-        this.parseInteger = Math.ceil
-        break
-      case 'round':
-        this.parseInteger = Math.round
-        break
-      default:
-        this.parseInteger = Math.trunc
-        break
-    }
-  }
-
-  asAny (i) {
-    return JSON.stringify(i)
-  }
-
-  asNull () {
-    return 'null'
-  }
-
-  asInteger (i) {
-    if (typeof i === 'bigint') {
-      return i.toString()
-    } else if (Number.isInteger(i)) {
-      return '' + i
-    } else {
-      /* eslint no-undef: "off" */
-      const integer = this.parseInteger(i)
-      if (Number.isNaN(integer)) {
-        throw new Error(`The value "${i}" cannot be converted to an integer.`)
-      } else {
-        return '' + integer
-      }
-    }
-  }
-
-  asIntegerNullable (i) {
-    return i === null ? 'null' : this.asInteger(i)
-  }
-
-  asNumber (i) {
-    const num = Number(i)
-    if (Number.isNaN(num)) {
-      throw new Error(`The value "${i}" cannot be converted to a number.`)
-    } else {
-      return '' + num
-    }
-  }
-
-  asNumberNullable (i) {
-    return i === null ? 'null' : this.asNumber(i)
-  }
-
-  asBoolean (bool) {
-    return bool && 'true' || 'false' // eslint-disable-line
-  }
-
-  asBooleanNullable (bool) {
-    return bool === null ? 'null' : this.asBoolean(bool)
-  }
-
-  asDatetime (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
-    if (date instanceof Date) {
-      return quotes + date.toISOString() + quotes
-    }
-    return this.asString(date, skipQuotes)
-  }
-
-  asDatetimeNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asDatetime(date, skipQuotes)
-  }
-
-  asDate (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
-    if (date instanceof Date) {
-      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
-    }
-    return this.asString(date, skipQuotes)
-  }
-
-  asDateNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asDate(date, skipQuotes)
-  }
-
-  asTime (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
-    if (date instanceof Date) {
-      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
-    }
-    return this.asString(date, skipQuotes)
-  }
-
-  asTimeNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asTime(date, skipQuotes)
-  }
-
-  asString (str, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
-    if (str instanceof Date) {
-      return quotes + str.toISOString() + quotes
-    } else if (str === null) {
-      return quotes + quotes
-    } else if (str instanceof RegExp) {
-      str = str.source
-    } else if (typeof str !== 'string') {
-      str = str.toString()
-    }
-    // If we skipQuotes it means that we are using it as test
-    // no need to test the string length for the render
-    if (skipQuotes) {
-      return str
-    }
-
-    if (str.length < 42) {
-      return this.asStringSmall(str)
-    } else {
-      return JSON.stringify(str)
-    }
-  }
-
-  asStringNullable (str) {
-    return str === null ? 'null' : this.asString(str)
-  }
-
-  // magically escape strings for json
-  // relying on their charCodeAt
-  // everything below 32 needs JSON.stringify()
-  // every string that contain surrogate needs JSON.stringify()
-  // 34 and 92 happens all the time, so we
-  // have a fast case for them
-  asStringSmall (str) {
-    const l = str.length
-    let result = ''
-    let last = 0
-    let found = false
-    let surrogateFound = false
-    let point = 255
-    // eslint-disable-next-line
-    for (var i = 0; i < l && point >= 32; i++) {
-      point = str.charCodeAt(i)
-      if (point >= 0xD800 && point <= 0xDFFF) {
-        // The current character is a surrogate.
-        surrogateFound = true
-      }
-      if (point === 34 || point === 92) {
-        result += str.slice(last, i) + '\\'
-        last = i
-        found = true
-      }
-    }
-
-    if (!found) {
-      result = str
-    } else {
-      result += str.slice(last)
-    }
-    return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
-  }
-}
+let contextFunctions = null
 
 function build (schema, options) {
   arrayItemsReferenceSerializersMap.clear()
   objectReferenceSerializersMap.clear()
   schemaReferenceMap.clear()
 
+  contextFunctions = []
   options = options || {}
 
-  ajvInstance = new Ajv({ ...options.ajv, strictSchema: false, uriResolver: fastUri })
-  ajvFormats(ajvInstance)
-
-  const validateDateTimeFormat = ajvFormats.get('date-time').validate
-  const validateDateFormat = ajvFormats.get('date').validate
-  const validateTimeFormat = ajvFormats.get('time').validate
-
-  ajvInstance.addKeyword({
-    keyword: 'fjs_date_type',
-    validate: (schema, date) => {
-      if (date instanceof Date) {
-        return true
-      }
-      if (schema === 'date-time') {
-        return validateDateTimeFormat(date)
-      }
-      if (schema === 'date') {
-        return validateDateFormat(date)
-      }
-      if (schema === 'time') {
-        return validateTimeFormat(date)
-      }
-      return false
-    }
-  })
+  ajvInstance = buildAjv(options.ajv)
 
   isValidSchema(schema)
   if (options.schema) {
@@ -303,29 +113,50 @@ function build (schema, options) {
     schema.type = inferTypeByKeyword(schema)
   }
 
-  const { code, laterCode } = buildValue('', 'main', 'input', location)
+  const code = buildValue('main', 'input', location)
+
   const contextFunctionCode = `
-    'use strict'
     function main (input) {
       let json = ''
       ${code}
       return json
     }
-    ${laterCode}
+    ${contextFunctions.join('\n')}
     return main
     `
 
   const dependenciesName = ['ajv', 'serializer', contextFunctionCode]
 
   if (options.debugMode) {
+    options.mode = 'debug'
+  }
+
+  if (options.mode === 'debug') {
     return { code: dependenciesName.join('\n'), ajv: ajvInstance }
   }
 
+  if (options.mode === 'standalone') {
+    return `
+'use strict'
+
+const Serializer = require('fast-json-stringify/serializer')
+const buildAjv = require('fast-json-stringify/ajv')
+
+const serializer = new Serializer(${JSON.stringify(options || {})})
+const ajv = buildAjv(${JSON.stringify(options.ajv || {})})
+
+${contextFunctionCode.replace('return main', '')}
+
+module.exports = main
+    `
+  }
+
   /* eslint no-new-func: "off" */
   const contextFunc = new Function('ajv', 'serializer', contextFunctionCode)
   const stringifyFunc = contextFunc(ajvInstance, serializer)
 
   ajvInstance = null
+  contextFunctions = null
   arrayItemsReferenceSerializersMap.clear()
   objectReferenceSerializersMap.clear()
   schemaReferenceMap.clear()
@@ -408,7 +239,6 @@ function addPatternProperties (location) {
       for (var i = 0; i < keys.length; i++) {
         if (properties[keys[i]]) continue
   `
-  let laterCode = ''
 
   Object.keys(pp).forEach((regex, index) => {
     let ppLocation = mergeLocation(location, { schema: pp[regex] })
@@ -423,27 +253,24 @@ function addPatternProperties (location) {
       throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`)
     }
 
-    const valueCode = buildValue('', '', 'obj[keys[i]]', ppLocation)
-    laterCode += valueCode.laterCode
+    const valueCode = buildValue('', 'obj[keys[i]]', ppLocation)
     code += `
       if (/${regex.replace(/\\*\//g, '\\/')}/.test(keys[i])) {
         ${addComma}
         json += serializer.asString(keys[i]) + ':'
-        ${valueCode.code}
+        ${valueCode}
         continue
       }
     `
   })
   if (schema.additionalProperties) {
-    const additionalPropertyCode = additionalProperty(location)
-    code += additionalPropertyCode.code
-    laterCode += additionalPropertyCode.laterCode
+    code += additionalProperty(location)
   }
 
   code += `
       }
   `
-  return { code, laterCode }
+  return code
 }
 
 function additionalProperty (location) {
@@ -457,7 +284,7 @@ function additionalProperty (location) {
         }
     `
 
-    return { code, laterCode: '' }
+    return code
   }
   let apLocation = mergeLocation(location, { schema: ap })
   if (ap.$ref) {
@@ -465,29 +292,26 @@ function additionalProperty (location) {
     ap = apLocation.schema
   }
 
-  const valueCode = buildValue('', '', 'obj[keys[i]]', apLocation)
+  const valueCode = buildValue('', 'obj[keys[i]]', apLocation)
 
   code += `
     ${addComma}
     json += serializer.asString(keys[i]) + ':'
-    ${valueCode.code}
+    ${valueCode}
   `
 
-  return { code, laterCode: valueCode.laterCode }
+  return code
 }
 
 function addAdditionalProperties (location) {
-  const additionalPropertyCode = additionalProperty(location)
-  const code = `
+  return `
       var properties = ${JSON.stringify(location.schema.properties)} || {}
       var keys = Object.keys(obj)
       for (var i = 0; i < keys.length; i++) {
         if (properties[keys[i]]) continue
-        ${additionalPropertyCode.code}
+        ${additionalProperty(location)}
       }
   `
-
-  return { code, laterCode: additionalPropertyCode.laterCode }
 }
 
 function idFinder (schema, searchedId) {
@@ -621,7 +445,7 @@ function refFinder (ref, location) {
   }
 }
 
-function buildCode (location, code, laterCode, locationPath) {
+function buildCode (location, locationPath) {
   if (location.schema.$ref) {
     location = refFinder(location.schema.$ref, location)
   }
@@ -629,6 +453,8 @@ function buildCode (location, code, laterCode, locationPath) {
   const schema = location.schema
   const required = schema.required || []
 
+  let code = ''
+
   Object.keys(schema.properties || {}).forEach((key) => {
     let propertyLocation = mergeLocation(location, { schema: schema.properties[key] })
     if (schema.properties[key].$ref) {
@@ -648,9 +474,7 @@ function buildCode (location, code, laterCode, locationPath) {
         json += ${asString} + ':'
       `
 
-    const result = buildValue(laterCode, locationPath + key, `obj[${JSON.stringify(key)}]`, mergeLocation(propertyLocation, { schema: schema.properties[key] }))
-    code += result.code
-    laterCode = result.laterCode
+    code += buildValue(locationPath + key, `obj[${JSON.stringify(key)}]`, mergeLocation(propertyLocation, { schema: schema.properties[key] }))
 
     const defaultValue = schema.properties[key].default
     if (defaultValue !== undefined) {
@@ -676,7 +500,7 @@ function buildCode (location, code, laterCode, locationPath) {
     code += `if (obj['${requiredProperty}'] === undefined) throw new Error('"${requiredProperty}" is required!')\n`
   }
 
-  return { code, laterCode }
+  return code
 }
 
 function mergeAllOfSchema (location, schema, mergedSchema) {
@@ -771,24 +595,17 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
 
 function buildInnerObject (location, locationPath) {
   const schema = location.schema
-  const result = buildCode(location, '', '', locationPath)
+  let code = buildCode(location, locationPath)
   if (schema.patternProperties) {
-    const { code, laterCode } = addPatternProperties(location)
-    result.code += code
-    result.laterCode += laterCode
+    code += addPatternProperties(location)
   } else if (schema.additionalProperties && !schema.patternProperties) {
-    const { code, laterCode } = addAdditionalProperties(location)
-    result.code += code
-    result.laterCode += laterCode
+    code += addAdditionalProperties(location)
   }
-  return result
+  return code
 }
 
 function addIfThenElse (location, locationPath) {
   let code = ''
-  let r
-  let laterCode = ''
-  let innerR
 
   const schema = location.schema
   const copy = merge({}, schema)
@@ -809,14 +626,10 @@ function addIfThenElse (location, locationPath) {
     if (valid) {
   `
   if (merged.if && merged.then) {
-    innerR = addIfThenElse(mergedLocation, locationPath + 'Then')
-    code += innerR.code
-    laterCode = innerR.laterCode
+    code += addIfThenElse(mergedLocation, locationPath + 'Then')
   }
 
-  r = buildInnerObject(mergedLocation, locationPath + 'Then')
-  code += r.code
-  laterCode += r.laterCode
+  code += buildInnerObject(mergedLocation, locationPath + 'Then')
 
   code += `
     }
@@ -829,19 +642,15 @@ function addIfThenElse (location, locationPath) {
     `
 
   if (merged.if && merged.then) {
-    innerR = addIfThenElse(mergedLocation, locationPath + 'Else')
-    code += innerR.code
-    laterCode += innerR.laterCode
+    code += addIfThenElse(mergedLocation, locationPath + 'Else')
   }
 
-  r = buildInnerObject(mergedLocation, locationPath + 'Else')
-  code += r.code
-  laterCode += r.laterCode
+  code += buildInnerObject(mergedLocation, locationPath + 'Else')
 
   code += `
       }
     `
-  return { code, laterCode }
+  return code
 }
 
 function toJSON (variableName) {
@@ -851,76 +660,63 @@ function toJSON (variableName) {
   `
 }
 
-function buildObject (location, code, functionName, locationPath) {
+function buildObject (location, locationPath) {
   const schema = location.schema
   if (schema.$id !== undefined) {
     schemaReferenceMap.set(schema.$id, schema)
   }
-  code += `
+
+  if (objectReferenceSerializersMap.has(schema)) {
+    return objectReferenceSerializersMap.get(schema)
+  }
+
+  const functionName = generateFuncName()
+  objectReferenceSerializersMap.set(schema, functionName)
+
+  let functionCode = `
     function ${functionName} (input) {
       // ${locationPath}
   `
   if (schema.nullable) {
-    code += `
-      if(input === null) {
+    functionCode += `
+      if (input === null) {
         return 'null';
       }
   `
   }
 
-  if (objectReferenceSerializersMap.has(schema) && objectReferenceSerializersMap.get(schema) !== functionName) {
-    code += `
-      return ${objectReferenceSerializersMap.get(schema)}(input)
-    }
-    `
-    return code
-  }
-  objectReferenceSerializersMap.set(schema, functionName)
-
-  code += `
+  functionCode += `
       var obj = ${toJSON('input')}
       var json = '{'
       var addComma = false
   `
 
-  let r
+  let rCode
   if (schema.if && schema.then) {
-    code += `
+    functionCode += `
       var valid
     `
-    r = addIfThenElse(location, locationPath)
+    rCode = addIfThenElse(location, locationPath)
   } else {
-    r = buildInnerObject(location, locationPath)
+    rCode = buildInnerObject(location, locationPath)
   }
 
   // Removes the comma if is the last element of the string (in case there are not properties)
-  code += `${r.code}
+  functionCode += `${rCode}
       json += '}'
       return json
     }
-    ${r.laterCode}
   `
 
-  return code
+  contextFunctions.push(functionCode)
+  return functionName
 }
 
-function buildArray (location, code, functionName, locationPath) {
+function buildArray (location, locationPath) {
   let schema = location.schema
   if (schema.$id !== undefined) {
     schemaReferenceMap.set(schema.$id, schema)
   }
-  code += `
-    function ${functionName} (obj) {
-      // ${locationPath}
-  `
-  if (schema.nullable) {
-    code += `
-      if(obj === null) {
-        return 'null';
-      }
-    `
-  }
-  const laterCode = ''
 
   // default to any items type
   if (!schema.items) {
@@ -936,85 +732,105 @@ function buildArray (location, code, functionName, locationPath) {
 
     location = refFinder(schema.items.$ref, location)
     schema.items = location.schema
+  }
 
-    if (arrayItemsReferenceSerializersMap.has(schema.items)) {
-      code += `
-      return ${arrayItemsReferenceSerializersMap.get(schema.items)}(obj)
-      }
-      `
-      return code
-    }
-    arrayItemsReferenceSerializersMap.set(schema.items, functionName)
+  if (arrayItemsReferenceSerializersMap.has(schema.items)) {
+    return arrayItemsReferenceSerializersMap.get(schema.items)
   }
 
-  let result = { code: '', laterCode: '' }
-  const accessor = '[i]'
-  if (Array.isArray(schema.items)) {
-    result = schema.items.reduce((res, item, i) => {
-      const tmpRes = buildValue(laterCode, locationPath + accessor + i, 'obj[i]', mergeLocation(location, { schema: item }))
-      const condition = `i === ${i} && ${buildArrayTypeCondition(item.type, accessor)}`
-      return {
-        code: `${res.code}
-        ${i > 0 ? 'else' : ''} if (${condition}) {
-          ${tmpRes.code}
-        }`,
-        laterCode: `${res.laterCode}
-        ${tmpRes.laterCode}`
-      }
-    }, result)
+  const functionName = generateFuncName()
+  arrayItemsReferenceSerializersMap.set(schema.items, functionName)
 
-    if (schema.additionalItems) {
-      const tmpRes = buildValue(laterCode, locationPath + accessor, 'obj[i]', mergeLocation(location, { schema: schema.items }))
-      result.code += `
-      else if (i >= ${schema.items.length}) {
-        ${tmpRes.code}
-      }
-      `
-    }
+  let functionCode = `
+    function ${functionName} (obj) {
+      // ${locationPath}
+  `
 
-    result.code += `
-    else {
-      throw new Error(\`Item at $\{i} does not match schema definition.\`)
-    }
+  if (schema.nullable) {
+    functionCode += `
+      if (obj === null) {
+        return 'null';
+      }
     `
-  } else {
-    result = buildValue(laterCode, locationPath + accessor, 'obj[i]', mergeLocation(location, { schema: schema.items }))
   }
 
-  code += `
+  functionCode += `
     if (!Array.isArray(obj)) {
       throw new TypeError(\`The value '$\{obj}' does not match schema definition.\`)
     }
+    const arrayLength = obj.length
   `
 
-  code += 'const arrayLength = obj.length\n'
+  if (!schema.additionalItems) {
+    functionCode += `
+      if (arrayLength > ${schema.items.length}) {
+        throw new Error(\`Item at ${schema.items.length} does not match schema definition.\`)
+      }
+    `
+  }
+
   if (largeArrayMechanism !== 'default') {
     if (largeArrayMechanism === 'json-stringify') {
-      code += `if (arrayLength && arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
+      functionCode += `if (arrayLength && arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
     } else {
       throw new Error(`Unsupported large array mechanism ${largeArrayMechanism}`)
     }
   }
 
-  code += `
-    let jsonOutput= ''
-    for (let i = 0; i < arrayLength; i++) {
-      let json = ''
-      ${result.code}
-      jsonOutput += json
+  functionCode += `
+    let jsonOutput = ''
+  `
 
-      if (json.length > 0 && i < arrayLength - 1) {
-        jsonOutput += ','
-      }
+  const accessor = '[i]'
+  if (Array.isArray(schema.items)) {
+    for (let i = 0; i < schema.items.length; i++) {
+      const item = schema.items[i]
+      const tmpRes = buildValue(locationPath + accessor + i, `obj[${i}]`, mergeLocation(location, { schema: item }))
+      functionCode += `
+        if (${i} < arrayLength) {
+          if (${buildArrayTypeCondition(item.type, `[${i}]`)}) {
+            let json = ''
+            ${tmpRes}
+            jsonOutput += json
+            if (${i} < arrayLength - 1) {
+              jsonOutput += ','
+            }
+          } else {
+            throw new Error(\`Item at ${i} does not match schema definition.\`)
+          }
+        }
+        `
+    }
+
+    if (schema.additionalItems) {
+      functionCode += `
+        for (let i = ${schema.items.length}; i < arrayLength; i++) {
+          let json = JSON.stringify(obj[i])
+          jsonOutput += json
+          if (i < arrayLength - 1) {
+            jsonOutput += ','
+          }
+        }`
     }
+  } else {
+    const code = buildValue(locationPath + accessor, 'obj[i]', mergeLocation(location, { schema: schema.items }))
+    functionCode += `
+      for (let i = 0; i < arrayLength; i++) {
+        let json = ''
+        ${code}
+        jsonOutput += json
+        if (i < arrayLength - 1) {
+          jsonOutput += ','
+        }
+      }`
+  }
+
+  functionCode += `
     return \`[\${jsonOutput}]\`
   }`
 
-  code += `
-  ${result.laterCode}
-  `
-
-  return code
+  contextFunctions.push(functionCode)
+  return functionName
 }
 
 function buildArrayTypeCondition (type, accessor) {
@@ -1083,7 +899,7 @@ function generateFuncName () {
   return 'anonymous' + genFuncNameCounter++
 }
 
-function buildValue (laterCode, locationPath, input, location) {
+function buildValue (locationPath, input, location) {
   let schema = location.schema
 
   if (schema.$ref) {
@@ -1134,13 +950,11 @@ function buildValue (laterCode, locationPath, input, location) {
       code += `json += ${funcName}(${input})`
       break
     case 'object':
-      funcName = generateFuncName()
-      laterCode = buildObject(location, laterCode, funcName, locationPath)
+      funcName = buildObject(location, locationPath)
       code += `json += ${funcName}(${input})`
       break
     case 'array':
-      funcName = generateFuncName()
-      laterCode = buildArray(location, laterCode, funcName, locationPath)
+      funcName = buildArray(location, locationPath)
       code += `json += ${funcName}(${input})`
       break
     case undefined:
@@ -1148,7 +962,7 @@ function buildValue (laterCode, locationPath, input, location) {
         // beware: dereferenceOfRefs has side effects and changes schema.anyOf
         const locations = dereferenceOfRefs(location, schema.anyOf ? 'anyOf' : 'oneOf')
         locations.forEach((location, index) => {
-          const nestedResult = buildValue(laterCode, locationPath + 'i' + index, input, location)
+          const nestedResult = buildValue(locationPath + 'i' + index, input, location)
           // Since we are only passing the relevant schema to ajv.validate, it needs to be full dereferenced
           // otherwise any $ref pointing to an external schema would result in an error.
           // Full dereference of the schema happens as side effect of two functions:
@@ -1168,9 +982,8 @@ function buildValue (laterCode, locationPath, input, location) {
 
           code += `
             ${index === 0 ? 'if' : 'else if'}(ajv.validate("${schemaKey}", ${input}))
-              ${nestedResult.code}
+              ${nestedResult}
           `
-          laterCode = nestedResult.laterCode
         })
 
         code += `
@@ -1211,38 +1024,37 @@ function buildValue (laterCode, locationPath, input, location) {
         sortedTypes.forEach((type, index) => {
           const statement = index === 0 ? 'if' : 'else if'
           const tempSchema = Object.assign({}, schema, { type })
-          const nestedResult = buildValue(laterCode, locationPath, input, mergeLocation(location, { schema: tempSchema }))
+          const nestedResult = buildValue(locationPath, input, mergeLocation(location, { schema: tempSchema }))
           switch (type) {
             case 'string': {
               code += `
                 ${statement}(${input} === null || typeof ${input} === "${type}" || ${input} instanceof Date || ${input} instanceof RegExp || (typeof ${input} === "object" && Object.hasOwnProperty.call(${input}, "toString")))
-                  ${nestedResult.code}
+                  ${nestedResult}
               `
               break
             }
             case 'array': {
               code += `
                 ${statement}(Array.isArray(${input}))
-                  ${nestedResult.code}
+                  ${nestedResult}
               `
               break
             }
             case 'integer': {
               code += `
                 ${statement}(Number.isInteger(${input}) || ${input} === null)
-                  ${nestedResult.code}
+                  ${nestedResult}
               `
               break
             }
             default: {
               code += `
                 ${statement}(typeof ${input} === "${type}" || ${input} === null)
-                  ${nestedResult.code}
+                  ${nestedResult}
               `
               break
             }
           }
-          laterCode = nestedResult.laterCode
         })
         code += `
           else throw new Error(\`The value $\{JSON.stringify(${input})} does not match schema definition.\`)
@@ -1258,7 +1070,7 @@ function buildValue (laterCode, locationPath, input, location) {
       }
   }
 
-  return { code, laterCode }
+  return code
 }
 
 function extendDateTimeType (schema) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",

package/serializer.js

@@ -0,0 +1,168 @@
+'use strict'
+
+module.exports = class Serializer {
+  constructor (options = {}) {
+    switch (options.rounding) {
+      case 'floor':
+        this.parseInteger = Math.floor
+        break
+      case 'ceil':
+        this.parseInteger = Math.ceil
+        break
+      case 'round':
+        this.parseInteger = Math.round
+        break
+      default:
+        this.parseInteger = Math.trunc
+        break
+    }
+  }
+
+  asAny (i) {
+    return JSON.stringify(i)
+  }
+
+  asNull () {
+    return 'null'
+  }
+
+  asInteger (i) {
+    if (typeof i === 'bigint') {
+      return i.toString()
+    } else if (Number.isInteger(i)) {
+      return '' + i
+    } else {
+      /* eslint no-undef: "off" */
+      const integer = this.parseInteger(i)
+      if (Number.isNaN(integer)) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      } else {
+        return '' + integer
+      }
+    }
+  }
+
+  asIntegerNullable (i) {
+    return i === null ? 'null' : this.asInteger(i)
+  }
+
+  asNumber (i) {
+    const num = Number(i)
+    if (Number.isNaN(num)) {
+      throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else {
+      return '' + num
+    }
+  }
+
+  asNumberNullable (i) {
+    return i === null ? 'null' : this.asNumber(i)
+  }
+
+  asBoolean (bool) {
+    return bool && 'true' || 'false' // eslint-disable-line
+  }
+
+  asBooleanNullable (bool) {
+    return bool === null ? 'null' : this.asBoolean(bool)
+  }
+
+  asDatetime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + date.toISOString() + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asDatetimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDatetime(date, skipQuotes)
+  }
+
+  asDate (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asDateNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asDate(date, skipQuotes)
+  }
+
+  asTime (date, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
+    }
+    return this.asString(date, skipQuotes)
+  }
+
+  asTimeNullable (date, skipQuotes) {
+    return date === null ? 'null' : this.asTime(date, skipQuotes)
+  }
+
+  asString (str, skipQuotes) {
+    const quotes = skipQuotes === true ? '' : '"'
+    if (str instanceof Date) {
+      return quotes + str.toISOString() + quotes
+    } else if (str === null) {
+      return quotes + quotes
+    } else if (str instanceof RegExp) {
+      str = str.source
+    } else if (typeof str !== 'string') {
+      str = str.toString()
+    }
+    // If we skipQuotes it means that we are using it as test
+    // no need to test the string length for the render
+    if (skipQuotes) {
+      return str
+    }
+
+    if (str.length < 42) {
+      return this.asStringSmall(str)
+    } else {
+      return JSON.stringify(str)
+    }
+  }
+
+  asStringNullable (str) {
+    return str === null ? 'null' : this.asString(str)
+  }
+
+  // magically escape strings for json
+  // relying on their charCodeAt
+  // everything below 32 needs JSON.stringify()
+  // every string that contain surrogate needs JSON.stringify()
+  // 34 and 92 happens all the time, so we
+  // have a fast case for them
+  asStringSmall (str) {
+    const l = str.length
+    let result = ''
+    let last = 0
+    let found = false
+    let surrogateFound = false
+    let point = 255
+    // eslint-disable-next-line
+    for (var i = 0; i < l && point >= 32; i++) {
+      point = str.charCodeAt(i)
+      if (point >= 0xD800 && point <= 0xDFFF) {
+        // The current character is a surrogate.
+        surrogateFound = true
+      }
+      if (point === 34 || point === 92) {
+        result += str.slice(last, i) + '\\'
+        last = i
+        found = true
+      }
+    }
+
+    if (!found) {
+      result = str
+    } else {
+      result += str.slice(last)
+    }
+    return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+  }
+}

package/test/array.test.js

@@ -218,6 +218,35 @@ test('array items is a list of schema and additionalItems is true, just the desc
   t.equal(result, '{"foo":["foo","bar",1]}')
 })
 
+test('array items is a list of schema and additionalItems is true, just the described item is validated', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: [
+          {
+            type: 'string'
+          },
+          {
+            type: 'number'
+          }
+        ],
+        additionalItems: true
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const result = stringify({
+    foo: ['foo']
+  })
+
+  t.equal(result, '{"foo":["foo"]}')
+})
+
 test('array items is a list of schema and additionalItems is false', (t) => {
   t.plan(1)
 

package/test/standalone-mode.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const test = require('tap').test
+const fjs = require('..')
+const fs = require('fs')
+const path = require('path')
+
+function build (opts) {
+  return fjs({
+    title: 'default string',
+    type: 'object',
+    properties: {
+      firstName: {
+        type: 'string'
+      }
+    },
+    required: ['firstName']
+  }, opts)
+}
+
+const tmpDir = 'test/fixtures'
+
+test('activate standalone mode', async (t) => {
+  t.plan(2)
+  let code = build({ mode: 'standalone' })
+  t.type(code, 'string')
+  code = code.replace(/fast-json-stringify/g, '../..')
+
+  const destionation = path.resolve(tmpDir, 'standalone.js')
+
+  t.teardown(async () => {
+    await fs.promises.rm(destionation, { force: true })
+  })
+
+  await fs.promises.writeFile(destionation, code)
+  const standalone = require(destionation)
+  t.same(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted')
+})