fast-json-stringify 5.14.0 → 5.15.0

package/index.js

@@ -140,7 +140,19 @@ function build (schema, options) {
   const location = new Location(schema, context.rootSchemaId)
   const code = buildValue(context, location, 'input')
 
-  let contextFunctionCode
+  let contextFunctionCode = `
+    const JSON_STR_BEGIN_OBJECT = '{'
+    const JSON_STR_END_OBJECT = '}'
+    const JSON_STR_BEGIN_ARRAY = '['
+    const JSON_STR_END_ARRAY = ']'
+    const JSON_STR_COMMA = ','
+    const JSON_STR_COLONS = ':'
+    const JSON_STR_QUOTE = '"'
+    const JSON_STR_EMPTY_OBJECT = JSON_STR_BEGIN_OBJECT + JSON_STR_END_OBJECT
+    const JSON_STR_EMPTY_ARRAY = JSON_STR_BEGIN_ARRAY + JSON_STR_END_ARRAY
+    const JSON_STR_EMPTY_STRING = JSON_STR_QUOTE + JSON_STR_QUOTE
+    const JSON_STR_NULL = 'null'
+  `
 
   // If we have only the invocation of the 'anonymous0' function, we would
   // basically just wrap the 'anonymous0' function in the 'main' function and
@@ -148,13 +160,13 @@ function build (schema, options) {
   // wrapping and the unnecessary memory allocation by aliasing 'anonymous0' to
   // 'main'
   if (code === 'json += anonymous0(input)') {
-    contextFunctionCode = `
+    contextFunctionCode += `
     ${context.functions.join('\n')}
     const main = anonymous0
     return main
     `
   } else {
-    contextFunctionCode = `
+    contextFunctionCode += `
     function main (input) {
       let json = ''
       ${code}
@@ -284,7 +296,7 @@ function buildExtraObjectPropertiesSerializer (context, location, addComma) {
       code += `
         if (/${propertyKey.replace(/\\*\//g, '\\/')}/.test(key)) {
           ${addComma}
-          json += serializer.asString(key) + ':'
+          json += serializer.asString(key) + JSON_STR_COLONS
           ${buildValue(context, propertyLocation, 'value')}
           continue
         }
@@ -299,13 +311,13 @@ function buildExtraObjectPropertiesSerializer (context, location, addComma) {
     if (additionalPropertiesSchema === true) {
       code += `
         ${addComma}
-        json += serializer.asString(key) + ':' + JSON.stringify(value)
+        json += serializer.asString(key) + JSON_STR_COLONS + JSON.stringify(value)
       `
     } else {
       const propertyLocation = location.getPropertyLocation('additionalProperties')
       code += `
         ${addComma}
-        json += serializer.asString(key) + ':'
+        json += serializer.asString(key) + JSON_STR_COLONS
         ${buildValue(context, propertyLocation, 'value')}
       `
     }
@@ -333,7 +345,7 @@ function buildInnerObject (context, location) {
   )
   const hasRequiredProperties = requiredProperties.includes(propertiesKeys[0])
 
-  let code = ''
+  let code = 'let value\n'
 
   for (const key of requiredProperties) {
     if (!propertiesKeys.includes(key)) {
@@ -341,12 +353,12 @@ function buildInnerObject (context, location) {
     }
   }
 
-  code += 'let json = \'{\'\n'
+  code += 'let json = JSON_STR_BEGIN_OBJECT\n'
 
   let addComma = ''
   if (!hasRequiredProperties) {
     code += 'let addComma = false\n'
-    addComma = '!addComma && (addComma = true) || (json += \',\')'
+    addComma = '!addComma && (addComma = true) || (json += JSON_STR_COMMA)'
   }
 
   for (const key of propertiesKeys) {
@@ -360,10 +372,11 @@ function buildInnerObject (context, location) {
     const isRequired = requiredProperties.includes(key)
 
     code += `
-      if (obj[${sanitizedKey}] !== undefined) {
+      value = obj[${sanitizedKey}]
+      if (value !== undefined) {
         ${addComma}
         json += ${JSON.stringify(sanitizedKey + ':')}
-        ${buildValue(context, propertyLocation, `obj[${sanitizedKey}]`)}
+        ${buildValue(context, propertyLocation, 'value')}
       }`
 
     if (defaultValue !== undefined) {
@@ -391,7 +404,7 @@ function buildInnerObject (context, location) {
   }
 
   code += `
-    return json + '}'
+    return json + JSON_STR_END_OBJECT
   `
   return code
 }
@@ -438,7 +451,7 @@ function cloneOriginSchema (context, schema, schemaId) {
   for (const key in schema) {
     let value = schema[key]
 
-    if (key === '$ref' && value.charAt(0) === '#') {
+    if (key === '$ref' && typeof value === 'string' && value.charAt(0) === '#') {
       value = schemaId + value
     }
 
@@ -482,7 +495,7 @@ function buildObject (context, location) {
     // ${schemaRef}
     function ${functionName} (input) {
       const obj = ${toJSON('input')}
-      ${!nullable ? 'if (obj === null) return \'{}\'' : ''}
+      ${!nullable ? 'if (obj === null) return JSON_STR_EMPTY_OBJECT' : ''}
 
       ${buildInnerObject(context, location)}
     }
@@ -523,7 +536,7 @@ function buildArray (context, location) {
 
   const nullable = schema.nullable === true
   functionCode += `
-    ${!nullable ? 'if (obj === null) return \'[]\'' : ''}
+    ${!nullable ? 'if (obj === null) return JSON_STR_EMPTY_ARRAY' : ''}
     if (!Array.isArray(obj)) {
       throw new TypeError(\`The value of '${schemaRef}' does not match schema definition.\`)
     }
@@ -539,25 +552,26 @@ function buildArray (context, location) {
   }
 
   if (largeArrayMechanism === 'json-stringify') {
-    functionCode += `if (arrayLength && arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
+    functionCode += `if (arrayLength >= ${largeArraySize}) return JSON.stringify(obj)\n`
   }
 
   functionCode += `
-    let jsonOutput = ''
+    const arrayEnd = arrayLength - 1
+    let value
+    let json = ''
   `
 
   if (Array.isArray(itemsSchema)) {
     for (let i = 0; i < itemsSchema.length; i++) {
       const item = itemsSchema[i]
-      const tmpRes = buildValue(context, itemsLocation.getPropertyLocation(i), `obj[${i}]`)
+      functionCode += `value = obj[${i}]`
+      const tmpRes = buildValue(context, itemsLocation.getPropertyLocation(i), 'value')
       functionCode += `
         if (${i} < arrayLength) {
           if (${buildArrayTypeCondition(item.type, `[${i}]`)}) {
-            let json = ''
             ${tmpRes}
-            jsonOutput += json
-            if (${i} < arrayLength - 1) {
-              jsonOutput += ','
+            if (${i} < arrayEnd) {
+              json += JSON_STR_COMMA
             }
           } else {
             throw new Error(\`Item at ${i} does not match schema definition.\`)
@@ -569,9 +583,9 @@ function buildArray (context, location) {
     if (schema.additionalItems) {
       functionCode += `
         for (let i = ${itemsSchema.length}; i < arrayLength; i++) {
-          jsonOutput += JSON.stringify(obj[i])
-          if (i < arrayLength - 1) {
-            jsonOutput += ','
+          json += JSON.stringify(obj[i])
+          if (i < arrayEnd) {
+            json += JSON_STR_COMMA
           }
         }`
     }
@@ -579,17 +593,15 @@ function buildArray (context, location) {
     const code = buildValue(context, itemsLocation, 'obj[i]')
     functionCode += `
       for (let i = 0; i < arrayLength; i++) {
-        let json = ''
         ${code}
-        jsonOutput += json
-        if (i < arrayLength - 1) {
-          jsonOutput += ','
+        if (i < arrayEnd) {
+          json += JSON_STR_COMMA
         }
       }`
   }
 
   functionCode += `
-    return \`[\${jsonOutput}]\`
+    return JSON_STR_BEGIN_ARRAY + json + JSON_STR_END_ARRAY
   }`
 
   context.functions.push(functionCode)
@@ -600,33 +612,33 @@ function buildArrayTypeCondition (type, accessor) {
   let condition
   switch (type) {
     case 'null':
-      condition = `obj${accessor} === null`
+      condition = 'value === null'
       break
     case 'string':
-      condition = `typeof obj${accessor} === 'string' ||
-      obj${accessor} === null ||
-      obj${accessor} instanceof Date ||
-      obj${accessor} instanceof RegExp ||
+      condition = `typeof value === 'string' ||
+      value === null ||
+      value instanceof Date ||
+      value instanceof RegExp ||
       (
-        typeof obj${accessor} === "object" &&
-        typeof obj${accessor}.toString === "function" &&
-        obj${accessor}.toString !== Object.prototype.toString
+        typeof value === "object" &&
+        typeof value.toString === "function" &&
+        value.toString !== Object.prototype.toString
       )`
       break
     case 'integer':
-      condition = `Number.isInteger(obj${accessor})`
+      condition = 'Number.isInteger(value)'
       break
     case 'number':
-      condition = `Number.isFinite(obj${accessor})`
+      condition = 'Number.isFinite(value)'
       break
     case 'boolean':
-      condition = `typeof obj${accessor} === 'boolean'`
+      condition = 'typeof value === \'boolean\''
       break
     case 'object':
-      condition = `obj${accessor} && typeof obj${accessor} === 'object' && obj${accessor}.constructor === Object`
+      condition = 'value && typeof value === \'object\' && value.constructor === Object'
       break
     case 'array':
-      condition = `Array.isArray(obj${accessor})`
+      condition = 'Array.isArray(value)'
       break
     default:
       if (Array.isArray(type)) {
@@ -717,7 +729,7 @@ function buildSingleTypeSerializer (context, location, input) {
 
   switch (schema.type) {
     case 'null':
-      return 'json += \'null\''
+      return 'json += JSON_STR_NULL'
     case 'string': {
       if (schema.format === 'date-time') {
         return `json += serializer.asDateTime(${input})`
@@ -731,9 +743,9 @@ function buildSingleTypeSerializer (context, location, input) {
         return `
         if (typeof ${input} !== 'string') {
           if (${input} === null) {
-            json += '""'
+            json += JSON_STR_EMPTY_STRING
           } else if (${input} instanceof Date) {
-            json += '"' + ${input}.toISOString() + '"'
+            json += JSON_STR_QUOTE + ${input}.toISOString() + JSON_STR_QUOTE
           } else if (${input} instanceof RegExp) {
             json += serializer.asString(${input}.source)
           } else {
@@ -777,7 +789,7 @@ function buildConstSerializer (location, input) {
   if (hasNullType) {
     code += `
       if (${input} === null) {
-        json += 'null'
+        json += JSON_STR_NULL
       } else {
     `
   }
@@ -984,7 +996,7 @@ function buildValue (context, location, input) {
   if (nullable) {
     code += `
       if (${input} === null) {
-        json += 'null'
+        json += JSON_STR_NULL
       } else {
     `
   }

package/lib/serializer.js

@@ -24,38 +24,29 @@ module.exports = class Serializer {
   }
 
   asInteger (i) {
-    if (typeof i === 'number') {
-      if (Number.isInteger(i)) {
-        return '' + i
-      }
-      // check if number is Infinity or NaN
-      // eslint-disable-next-line no-self-compare
-      if (i === Infinity || i === -Infinity || i !== i) {
-        throw new Error(`The value "${i}" cannot be converted to an integer.`)
-      }
-      return this.parseInteger(i)
-    } else if (i === null) {
-      return '0'
+    if (Number.isInteger(i)) {
+      return '' + i
     } else if (typeof i === 'bigint') {
       return i.toString()
-    } else {
-      /* eslint no-undef: "off" */
-      const integer = this.parseInteger(i)
-      if (Number.isFinite(integer)) {
-        return '' + integer
-      } else {
-        throw new Error(`The value "${i}" cannot be converted to an integer.`)
-      }
     }
+    /* eslint no-undef: "off" */
+    const integer = this.parseInteger(i)
+    // check if number is Infinity or NaN
+    // eslint-disable-next-line no-self-compare
+    if (integer === Infinity || integer === -Infinity || integer !== integer) {
+      throw new Error(`The value "${i}" cannot be converted to an integer.`)
+    }
+    return '' + integer
   }
 
   asNumber (i) {
-    const num = Number(i)
+    // fast cast to number
+    const num = +i
     // check if number is NaN
     // eslint-disable-next-line no-self-compare
     if (num !== num) {
       throw new Error(`The value "${i}" cannot be converted to a number.`)
-    } else if (!Number.isFinite(num)) {
+    } else if (num === Infinity || num === -Infinity) {
       return 'null'
     } else {
       return '' + num
@@ -100,9 +91,34 @@ module.exports = class Serializer {
   }
 
   asString (str) {
-    if (str.length < 42) {
-      return this.asStringSmall(str)
-    } else if (str.length < 5000 && STR_ESCAPE.test(str) === false) {
+    const len = str.length
+    if (len < 42) {
+      // 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
+      let result = ''
+      let last = -1
+      let point = 255
+      // eslint-disable-next-line
+      for (var i = 0; i < len; i++) {
+        point = str.charCodeAt(i)
+        if (
+          point === 0x22 || // '"'
+          point === 0x5c // '\'
+        ) {
+          last === -1 && (last = 0)
+          result += str.slice(last, i) + '\\'
+          last = i
+        } else if (point < 32 || (point >= 0xD800 && point <= 0xDFFF)) {
+          // The current character is non-printable characters or a surrogate.
+          return JSON.stringify(str)
+        }
+      }
+      return (last === -1 && ('"' + str + '"')) || ('"' + result + str.slice(last) + '"')
+    } else if (len < 5000 && STR_ESCAPE.test(str) === false) {
       // Only use the regular expression for shorter input. The overhead is otherwise too much.
       return '"' + str + '"'
     } else {
@@ -114,37 +130,6 @@ module.exports = class Serializer {
     return '"' + 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 len = str.length
-    let result = ''
-    let last = -1
-    let point = 255
-
-    // eslint-disable-next-line
-    for (var i = 0; i < len; i++) {
-      point = str.charCodeAt(i)
-      if (
-        point === 0x22 || // '"'
-        point === 0x5c // '\'
-      ) {
-        last === -1 && (last = 0)
-        result += str.slice(last, i) + '\\'
-        last = i
-      } else if (point < 32 || (point >= 0xD800 && point <= 0xDFFF)) {
-        // The current character is non-printable characters or a surrogate.
-        return JSON.stringify(str)
-      }
-    }
-
-    return (last === -1 && ('"' + str + '"')) || ('"' + result + str.slice(last) + '"')
-  }
-
   getState () {
     return this._options
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.14.0",
+  "version": "5.15.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "type": "commonjs",

package/test/allof.test.js

@@ -717,3 +717,39 @@ test('external recursive allOfs', (t) => {
   const stringify = build(schema, { schema: { externalSchema } })
   t.equal(stringify(data), '{"a":{"bar":"42","foo":{}},"b":{"bar":"42","foo":{}}}')
 })
+
+test('do not crash with $ref prop', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with $ref',
+    type: 'object',
+    properties: {
+      outside: {
+        $ref: '#/$defs/outside'
+      }
+    },
+    $defs: {
+      inside: {
+        type: 'object',
+        properties: {
+          $ref: {
+            type: 'string'
+          }
+        }
+      },
+      outside: {
+        allOf: [{
+          $ref: '#/$defs/inside'
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+  const value = stringify({
+    outside: {
+      $ref: 'true'
+    }
+  })
+  t.equal(value, '{"outside":{"$ref":"true"}}')
+})