fast-json-stringify 5.15.1 → 5.16.1

package/lib/serializer.js

@@ -41,7 +41,7 @@ module.exports = class Serializer {
 
   asNumber (i) {
     // fast cast to number
-    const num = +i
+    const num = Number(i)
     // check if number is NaN
     // eslint-disable-next-line no-self-compare
     if (num !== num) {

package/lib/standalone.js

@@ -3,19 +3,22 @@
 function buildStandaloneCode (contextFunc, context, serializer, validator) {
   let ajvDependencyCode = ''
   if (context.validatorSchemasIds.size > 0) {
+    ajvDependencyCode += 'const Validator = require(\'fast-json-stringify/lib/validator\')\n'
     ajvDependencyCode += `const validatorState = ${JSON.stringify(validator.getState())}\n`
     ajvDependencyCode += 'const validator = Validator.restoreFromState(validatorState)\n'
   } else {
     ajvDependencyCode += 'const validator = null\n'
   }
 
+  // Don't need to keep external schemas once compiled
+  // validatorState will hold external schemas if it needs them
+  const { schema, ...serializerState } = serializer.getState()
+
   return `
   'use strict'
-  const { dependencies } = require('fast-json-stringify/lib/standalone')
-
-  const { Serializer, Validator } = dependencies
 
-  const serializerState = ${JSON.stringify(serializer.getState())}
+  const Serializer = require('fast-json-stringify/lib/serializer')
+  const serializerState = ${JSON.stringify(serializerState)}
   const serializer = Serializer.restoreFromState(serializerState)
 
   ${ajvDependencyCode}

package/package.json

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

package/test/asNumber.test.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const test = require('tap').test
+
+test('asNumber should convert BigInt', (t) => {
+  t.plan(1)
+  const Serializer = require('../lib/serializer')
+  const serializer = new Serializer()
+
+  const number = serializer.asNumber(11753021440n)
+
+  t.equal(number, '11753021440')
+})

package/test/standalone-mode.test.js

@@ -26,14 +26,14 @@ test('activate standalone mode', async (t) => {
   t.type(code, 'string')
   t.equal(code.indexOf('ajv'), -1)
 
-  const destionation = path.resolve(tmpDir, 'standalone.js')
+  const destination = path.resolve(tmpDir, 'standalone.js')
 
   t.teardown(async () => {
-    await fs.promises.rm(destionation, { force: true })
+    await fs.promises.rm(destination, { force: true })
   })
 
-  await fs.promises.writeFile(destionation, code)
-  const standalone = require(destionation)
+  await fs.promises.writeFile(destination, code)
+  const standalone = require(destination)
   t.same(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted')
 })
 
@@ -89,14 +89,14 @@ test('test ajv schema', async (t) => {
   t.type(code, 'string')
   t.equal(code.indexOf('ajv') > 0, true)
 
-  const destionation = path.resolve(tmpDir, 'standalone2.js')
+  const destination = path.resolve(tmpDir, 'standalone2.js')
 
   t.teardown(async () => {
-    await fs.promises.rm(destionation, { force: true })
+    await fs.promises.rm(destination, { force: true })
   })
 
-  await fs.promises.writeFile(destionation, code)
-  const standalone = require(destionation)
+  await fs.promises.writeFile(destination, code)
+  const standalone = require(destination)
   t.same(standalone({
     kind: 'foobar',
     foo: 'FOO',
@@ -119,3 +119,98 @@ test('test ajv schema', async (t) => {
     }]
   }))
 })
+
+test('no need to keep external schemas once compiled', async (t) => {
+  t.plan(1)
+  const externalSchema = {
+    first: {
+      definitions: {
+        id1: {
+          type: 'object',
+          properties: {
+            id1: {
+              type: 'integer'
+            }
+          }
+        }
+      }
+    }
+  }
+  const code = fjs({
+    $ref: 'first#/definitions/id1'
+  }, {
+    mode: 'standalone',
+    schema: externalSchema
+  })
+
+  const destination = path.resolve(tmpDir, 'standalone3.js')
+
+  t.teardown(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  await fs.promises.writeFile(destination, code)
+  const standalone = require(destination)
+
+  t.same(standalone({ id1: 5 }), JSON.stringify({ id1: 5 }), 'serialization works with external schemas')
+})
+
+test('no need to keep external schemas once compiled - with oneOf validator', async (t) => {
+  t.plan(2)
+
+  const externalSchema = {
+    ext: {
+      definitions: {
+        oBaz: {
+          type: 'object',
+          properties: {
+            baz: { type: 'number' }
+          },
+          required: ['baz']
+        },
+        oBar: {
+          type: 'object',
+          properties: {
+            bar: { type: 'string' }
+          },
+          required: ['bar']
+        },
+        other: {
+          type: 'string',
+          const: 'other'
+        }
+      }
+    }
+  }
+
+  const schema = {
+    title: 'object with oneOf property value containing refs to external schema',
+    type: 'object',
+    properties: {
+      oneOfSchema: {
+        oneOf: [
+          { $ref: 'ext#/definitions/oBaz' },
+          { $ref: 'ext#/definitions/oBar' }
+        ]
+      }
+    },
+    required: ['oneOfSchema']
+  }
+
+  const code = fjs(schema, {
+    mode: 'standalone',
+    schema: externalSchema
+  })
+
+  const destination = path.resolve(tmpDir, 'standalone-oneOf-ref.js')
+
+  t.teardown(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  await fs.promises.writeFile(destination, code)
+  const stringify = require(destination)
+
+  t.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
+  t.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
+})