fast-json-stringify 4.0.0 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "types": "index.d.ts",
@@ -37,7 +37,7 @@
     "benchmark": "^2.1.4",
     "chalk": "^4.1.2",
     "compile-json-stringify": "^0.1.2",
-    "inquirer": "^8.2.4",
+    "inquirer": "^9.0.0",
     "is-my-json-valid": "^2.20.0",
     "luxon": "^2.4.0",
     "pre-commit": "^1.2.2",
@@ -53,12 +53,8 @@
     "ajv": "^8.10.0",
     "ajv-formats": "^2.1.1",
     "deepmerge": "^4.2.2",
-    "fast-uri": "^2.0.0",
-    "rfdc": "^1.2.0",
-    "string-similarity": "^4.0.1"
-  },
-  "engines": {
-    "node": ">= 10.0.0"
+    "fast-uri": "^2.1.0",
+    "rfdc": "^1.2.0"
   },
   "standard": {
     "ignore": [

package/serializer.js

@@ -0,0 +1,163 @@
+'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) {
+    const quotes = '"'
+    if (date instanceof Date) {
+      return quotes + date.toISOString() + quotes
+    }
+    return this.asString(date)
+  }
+
+  asDatetimeNullable (date) {
+    return date === null ? 'null' : this.asDatetime(date)
+  }
+
+  asDate (date) {
+    const quotes = '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
+    }
+    return this.asString(date)
+  }
+
+  asDateNullable (date) {
+    return date === null ? 'null' : this.asDate(date)
+  }
+
+  asTime (date) {
+    const quotes = '"'
+    if (date instanceof Date) {
+      return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
+    }
+    return this.asString(date)
+  }
+
+  asTimeNullable (date) {
+    return date === null ? 'null' : this.asTime(date)
+  }
+
+  asString (str) {
+    const quotes = '"'
+    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 (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/standalone.js

@@ -0,0 +1,42 @@
+const fs = require('fs')
+const path = require('path')
+
+function buildStandaloneCode (options, ajvInstance, contextFunctionCode) {
+  const serializerCode = fs.readFileSync(path.join(__dirname, 'serializer.js')).toString()
+  let buildAjvCode = ''
+  let defaultAjvSchema = ''
+  const defaultMeta = ajvInstance.defaultMeta()
+  if (typeof defaultMeta === 'string') {
+    defaultAjvSchema = defaultMeta
+  } else {
+    defaultAjvSchema = defaultMeta.$id || defaultMeta.id
+  }
+  const shouldUseAjv = contextFunctionCode.indexOf('ajv') !== -1
+  // we need to export the custom json schema
+  let ajvSchemasCode = ''
+  if (shouldUseAjv) {
+    ajvSchemasCode += `const ajv = buildAjv(${JSON.stringify(options.ajv || {})})\n`
+    for (const [id, schema] of Object.entries(ajvInstance.schemas)) {
+      // should skip ajv default schema
+      if (id === defaultAjvSchema) continue
+      ajvSchemasCode += `ajv.addSchema(${JSON.stringify(schema.schema)}, "${id}")\n`
+    }
+    buildAjvCode = fs.readFileSync(path.join(__dirname, 'ajv.js')).toString()
+    buildAjvCode = buildAjvCode.replace("'use strict'", '').replace('module.exports = buildAjv', '')
+  }
+  return `
+  'use strict'
+
+  ${serializerCode.replace("'use strict'", '').replace('module.exports = ', '')}
+  ${buildAjvCode}
+
+  const serializer = new Serializer(${JSON.stringify(options || {})})
+  ${ajvSchemasCode}
+
+  ${contextFunctionCode.replace('return main', '')}
+
+  module.exports = main
+      `
+}
+
+module.exports = buildStandaloneCode

package/test/allof.test.js

@@ -402,12 +402,14 @@ test('object with external $refs in allOf', (t) => {
       }
     },
     second: {
-      id2: {
-        $id: '#id2',
-        type: 'object',
-        properties: {
-          id2: {
-            type: 'integer'
+      definitions: {
+        id2: {
+          $id: '#id2',
+          type: 'object',
+          properties: {
+            id2: {
+              type: 'integer'
+            }
           }
         }
       }
@@ -422,7 +424,7 @@ test('object with external $refs in allOf', (t) => {
         $ref: 'first#/definitions/id1'
       },
       {
-        $ref: 'second#id2'
+        $ref: 'second#/definitions/id2'
       }
     ]
   }

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)