New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
bison-types
Advanced tools
bison-types - npm Package Compare versions
Comparing version 3.0.3 to 4.0.0
| { | ||
| "name": "bison-types", | ||
| "version": "3.0.3", | ||
| "version": "4.0.0", | ||
| "description": "Convert between json and binary", | ||
| "main": "target/index.js", | ||
| "main": "src/index.js", | ||
| "scripts": { | ||
| "test": "mocha", | ||
| "compile": "coffee --output target --compile src", | ||
| "prepublish": "npm test && npm run compile" | ||
| "lint": "require-lint && eslint 'src/**/*.js' 'test/**/*.js'", | ||
| "prepublish": "npm test" | ||
| }, | ||
| "repository": { | ||
| "type": "git", | ||
| "url": "https://github.com/TabDigital/bison-types.git" | ||
| "url": "https://github.com/Tabcorp/bison-types.git" | ||
| }, | ||
@@ -24,16 +24,19 @@ "keywords": [ | ||
| "bugs": { | ||
| "url": "https://github.com/TabDigital/bison-types/issues" | ||
| "url": "https://github.com/Tabcorp/bison-types/issues" | ||
| }, | ||
| "dependencies": { | ||
| "big.js": "~3.1.3", | ||
| "clever-buffer": "^2.0.5", | ||
| "lodash": "^4.13.1" | ||
| "clever-buffer": "^3.0.0", | ||
| "lodash": "^4.17.15" | ||
| }, | ||
| "devDependencies": { | ||
| "coffee-script": "^1.10.0", | ||
| "mocha": "~2.5.1", | ||
| "should": "~8.4.0", | ||
| "sinon": "~1.17.4", | ||
| "cli-table": "~0.3.1" | ||
| "cli-table": "~0.3.1", | ||
| "eslint": "^5.16.0", | ||
| "eslint-config-airbnb-base": "^14.0.0", | ||
| "eslint-plugin-import": "^2.20.0", | ||
| "eslint-plugin-mocha": "^6.2.2", | ||
| "mocha": "~6.2.2", | ||
| "require-lint": "^1.3.0", | ||
| "should": "~13.0.0", | ||
| "sinon": "~1.17.4" | ||
| } | ||
| } |
597
README.md
@@ -26,46 +26,44 @@ # bison-types | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| types = bison.preCompile | ||
| # top-level type | ||
| var types = bison.preCompile({ | ||
| 'timeline': [ | ||
| {count: 'uint16'} | ||
| {messages: 'message[count]'} | ||
| ] | ||
| # sub type | ||
| { count: 'uint16' }, | ||
| { messages: 'message[count]' } | ||
| ], | ||
| 'message': [ | ||
| {id: 'uint8'} | ||
| {timestamp: 'uint16'} | ||
| {length: 'uint16'} | ||
| {text: 'utf-8(length)'} | ||
| { id: 'uint8' }, | ||
| { timestamp: 'uint16' }, | ||
| { length: 'uint16' }, | ||
| { text: 'utf-8(length)' } | ||
| ] | ||
| }); | ||
| # time to read! | ||
| // time to read! | ||
| buf = new Buffer [0x04, 0x92, 0x04, 0x3b, 0xf4, 0x2c, ...] | ||
| reader = new bison.Reader buf, types, {bigEndian: false} | ||
| json = reader.read 'timeline' | ||
| var buf = Buffer.from([0x04, 0x92, 0x04, 0x3b, 0xf4, 0x2c]); | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var json = reader.read('timeline'); | ||
| # or write ! | ||
| // or write ! | ||
| buf = new Buffer(1024) | ||
| writer = new bison.Writer buf, types, {bigEndian: false} | ||
| writer.write 'timeline', { | ||
| count: 1 | ||
| var buf = Buffer.alloc(1024); | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('timeline', { | ||
| count: 1, | ||
| messages: [ | ||
| { | ||
| id: 3 | ||
| date: new Date().getTime() | ||
| length: 11 | ||
| id: 3, | ||
| date: new Date().getTime(), | ||
| length: 11, | ||
| text: 'hello world' | ||
| } | ||
| ] | ||
| } | ||
| }); | ||
| ``` | ||
| *Note:* bison-types uses [clever-buffer](https://github.com/TabDigital/clever-buffer) under the hood for all buffer manipulation. | ||
| *Note:* bison-types uses [clever-buffer](https://github.com/Tabcorp/clever-buffer) under the hood for all buffer manipulation. | ||
@@ -92,20 +90,22 @@ | ||
| ```coffee | ||
| # will store the index in the array | ||
| levelIndex = bison.enumeration 'uint8', ['admin', 'reader', 'writer'] | ||
| ```js | ||
| will store the index in the array | ||
| var levelIndex = bison.enumeration('uint8', ['admin', 'reader', 'writer']); | ||
| # will store the value in the object | ||
| levelCode = bison.enumeration 'uint16', | ||
| 'admin': 0xb8a3 | ||
| 'reader': 0xb90a | ||
| // will store the value in the object | ||
| var levelCode = bison.enumeration('uint16', { | ||
| 'admin': 0xb8a3, | ||
| 'reader': 0xb90a, | ||
| 'writer': 0xf23c | ||
| }); | ||
| bison.preCompile | ||
| 'levelIndex': levelIndex | ||
| 'levelCode': levelCode | ||
| bison.preCompile({ | ||
| 'levelIndex': levelIndex, | ||
| 'levelCode': levelCode, | ||
| 'user': [ | ||
| {id: 'uint8'} | ||
| {levelX: levelIndex} | ||
| {levelY: levelCode} | ||
| { id: 'uint8' }, | ||
| { levelX: levelIndex }, | ||
| { levelY: levelCode } | ||
| ] | ||
| }); | ||
| ``` | ||
@@ -118,18 +118,18 @@ | ||
| ### By mapping it to another type | ||
| ```coffee | ||
| types = bison.preCompile | ||
| my-other-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'uint16'} | ||
| ] | ||
| my-type: [ | ||
| {c: 'my-other-type'} | ||
| {d: 'uint8'} | ||
| ] | ||
| ```js | ||
| var types = bison.preCompile({ | ||
| 'my-other-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'uint16' } | ||
| ], | ||
| 'my-type': [ | ||
| { c: 'my-other-type' }, | ||
| { d: 'uint8' } | ||
| ] | ||
| }); | ||
| ``` | ||
| would create an object like | ||
| ```coffee | ||
| myType = {c: {a: 12, b: 123}, d: 1234} | ||
| ```js | ||
| var myType = {c: {a: 12, b: 123}, d: 1234} | ||
| ``` | ||
@@ -139,13 +139,17 @@ | ||
| We expose the underlying [clever-buffer](https://github.com/TabDigital/clever-buffer) as @buffer. | ||
| We expose the underlying [clever-buffer](https://github.com/Tabcorp/clever-buffer) as @buffer. | ||
| You can call any of its methods | ||
| ```coffee | ||
| types = bison.preCompile | ||
| multiply: | ||
| _read: (multiplier) -> | ||
| @buffer.getUint8() * multiplier | ||
| _write: (val, multiplier) -> | ||
| @buffer.writeUInt8(val * multiplier) | ||
| ```js | ||
| var types = bison.preCompile({ | ||
| multiply: { | ||
| _read: function(multiplier) { | ||
| return this.buffer.getUint8() * multiplier; | ||
| }, | ||
| _write: function(val, multiplier) { | ||
| return this.buffer.writeUInt8(val * multiplier); | ||
| } | ||
| } | ||
| }); | ||
| ``` | ||
@@ -159,61 +163,62 @@ would multiply the value read from the buffer before returning it when reading | ||
| You can also pass in options, look at [clever-buffer](https://github.com/TabDigital/clever-buffer) for a full list of options | ||
| You can also pass in options, look at [clever-buffer](https://github.com/Tabcorp/clever-buffer) for a full list of options | ||
| ### Reading some integers | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.from([0x01, 0x02, 0x03, 0x04]); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'uint8' }, | ||
| { c: 'uint8' }, | ||
| { d: 'uint8' } | ||
| ] | ||
| }); | ||
| buf = new Buffer [ 0x01, 0x02, 0x03, 0x04 ] | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'uint8'} | ||
| {c: 'uint8'} | ||
| {d: 'uint8'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| reader = new bison.Reader buf, types, options | ||
| myType = reader.read('my-type') # myType = { a: 1, b: 2, c: 3, d: 4 } | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var myType = reader.read('my-type'); | ||
| ``` | ||
| ### Reading a string | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| buf = new Buffer [0x48, 0x45, 0x4C, 0x4C, 0x4F] | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| a: 'utf-8(5)' | ||
| ] | ||
| options = {bigEndian: false} | ||
| reader = new bison.Reader buf, types, options | ||
| myType = reader.read('my-type') # myType = { a: 'HELLO' } | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.from([0x48, 0x45, 0x4C, 0x4C, 0x4F]); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'utf-8(5)' } | ||
| ] | ||
| }); | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var myType = reader.read('my-type'); | ||
| ``` | ||
| ### Reading a string with latin1 encoding | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.from([0x48, 0xC9, 0x4C, 0x4C, 0x4F]); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'latin1(5)' } | ||
| ] | ||
| }); | ||
| buf = new Buffer [0x48, 0xC9, 0x4C, 0x4C, 0x4F] | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| a: 'latin1(5)' | ||
| ] | ||
| options = {bigEndian: false} | ||
| reader = new bison.Reader buf, types, options | ||
| myType = reader.read('my-type') # myType = { a: 'HELLO' } | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var myType = reader.read('my-type'); | ||
| ``` | ||
| ### Reading a multi-byte string | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.from([0x48, 0xC3, 0x89, 0x4C, 0x4C, 0x4F]); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'utf-8(6)' } | ||
| ] | ||
| }); | ||
| buf = new Buffer [0x48, 0xC3, 0x89, 0x4C, 0x4C, 0x4F] | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| a: 'utf-8(6)' | ||
| ] | ||
| options = {bigEndian: false} | ||
| reader = new bison.Reader buf, types, options | ||
| myType = reader.read('my-type') # myType = { a: 'HÉLLO' } | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var myType = reader.read('my-type'); | ||
| // myType = { a: 'HÉLLO' } | ||
| ``` | ||
@@ -223,18 +228,18 @@ | ||
| The power of bison-types is evident as you define more complex types | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.from([0x01, 0x03, 0x04]); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'my-other-type' } | ||
| ], | ||
| 'my-other-type': [ | ||
| { c: 'uint8' }, | ||
| { d: 'uint8' } | ||
| ] | ||
| }); | ||
| buf = new Buffer [ 0x01, 0x03, 0x04 ] | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'my-other-type'} | ||
| ] | ||
| my-other-type: [ | ||
| {c: 'uint8'} | ||
| {d: 'uint8'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| reader = new bison.Reader buf, types, options | ||
| myType = reader.read('my-type') # myType = { a: 1, b: { c: 3, d: 4 }} | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var myType = reader.read('my-type'); | ||
| ``` | ||
@@ -245,16 +250,19 @@ | ||
| The power of bison-types is evident as you define more complex types | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.from([0x04, 0x02]); | ||
| var types = bison.preCompile({ | ||
| mult: { | ||
| _read: function(val) { | ||
| return this.buffer.getUInt8() * val; | ||
| } | ||
| }, | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'mult(a)' } | ||
| ] | ||
| }); | ||
| buf = new Buffer [ 0x04, 0x02 ] | ||
| types = bison.preCompile | ||
| mult: | ||
| _read: (val) -> @buffer.getUInt8() * val | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'mult(a)'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| reader = new bison.Reader buf, types, options | ||
| myType = reader.read('my-type') # myType = { a: 4, b: 8} | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var myType = reader.read('my-type'); | ||
| ``` | ||
@@ -264,17 +272,18 @@ ### Arrays | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| buf = new Buffer [ 0x03, 0x01, 0x02, 0x03 ] | ||
| types = bison.preCompile | ||
| object: [ | ||
| c: 'uint8' | ||
| ] | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'object[a]'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| reader = new bison.Reader buf, types, options | ||
| myType = reader.read('my-type') | ||
| # myType = { a: 3, b:[{c:1},{c:2},{c:3}] } | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.from([0x03, 0x01, 0x02, 0x03]); | ||
| var types = bison.preCompile({ | ||
| object: [ | ||
| { c: 'uint8' } | ||
| ], | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'object[a]' } | ||
| ] | ||
| }); | ||
| var reader = new bison.Reader(buf, types, { bigEndian: false }); | ||
| var myType = reader.read('my-type'); | ||
| // myType = { a: 3, b:[{c:1},{c:2},{c:3}] } | ||
| ``` | ||
@@ -289,77 +298,77 @@ | ||
| ### Writing some integers | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(4); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'uint8' }, | ||
| { c: 'uint8' }, | ||
| { d: 'uint8' } | ||
| ] | ||
| }); | ||
| buf = new Buffer 4 | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'uint8'} | ||
| {c: 'uint8'} | ||
| {d: 'uint8'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 1, b: 2, c: 3, d: 4 } | ||
| # buf will equal [ 0x01, 0x02, 0x03, 0x04 ] | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { a: 1, b: 2, c: 3, d: 4 }); | ||
| // buf will equal [ 0x01, 0x02, 0x03, 0x04 ] | ||
| ``` | ||
| ### Writing a string | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| buf = new Buffer 5 | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| a: 'utf-8' | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 'HELLO' } | ||
| # buf will equal [0x48, 0x45, 0x4C, 0x4C, 0x4F] | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(5); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'utf-8' } | ||
| ] | ||
| }); | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { a: 'HELLO' }); | ||
| // buf will equal [0x48, 0x45, 0x4C, 0x4C, 0x4F] | ||
| ``` | ||
| ### Writing a string with latin1 encoding | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(5); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'latin1' } | ||
| ] | ||
| }); | ||
| buf = new Buffer 5 | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| a: 'latin1' | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 'HÉLLO' } | ||
| # buf will equal [0x48, 0xC9, 0x4C, 0x4C, 0x4F] | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { a: 'HÉLLO' }); | ||
| // buf will equal [0x48, 0xC9, 0x4C, 0x4C, 0x4F] | ||
| ``` | ||
| ### Only writing a certain length of string | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| buf = new Buffer 10 | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| a: 'utf-8(5)' | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 'HELLOWORLD' } | ||
| # buf will equal [0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00] | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(10); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'utf-8(5)' } | ||
| ] | ||
| }); | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { a: 'HELLOWORLD' }); | ||
| // buf will equal [0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00] | ||
| ``` | ||
| ### Writing a multi-byte string | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(6); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'utf-8' } | ||
| ] | ||
| }); | ||
| buf = new Buffer 6 | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| a: 'utf-8' | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 'HÉLLO' } | ||
| # buf will equal [0x48, 0xC3, 0x89, 0x4C, 0x4C, 0x4F] | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { a: 'HÉLLO' }); | ||
| // buf will equal [0x48, 0xC3, 0x89, 0x4C, 0x4C, 0x4F] | ||
| ``` | ||
@@ -369,19 +378,22 @@ | ||
| The power of bison-types is evident as you define more complex types | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(4); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'my-other-type' } | ||
| ], | ||
| 'my-other-type': [ | ||
| { c: 'uint8' }, | ||
| { d: 'uint8' } | ||
| ] | ||
| }); | ||
| buf = new Buffer 4 | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'my-other-type'} | ||
| ] | ||
| my-other-type: [ | ||
| {c: 'uint8'} | ||
| {d: 'uint8'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 1, b: { c: 3, d: 4 }} | ||
| # buf will equal [ 0x01, 0x03, 0x04 ] | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { | ||
| a: 1, | ||
| b: { c: 3, d: 4 } | ||
| }); | ||
| // buf will equal [ 0x01, 0x03, 0x04 ] | ||
| ``` | ||
@@ -392,33 +404,37 @@ | ||
| The power of bison-types is evident as you define more complex types | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(2); | ||
| var types = bison.preCompile({ | ||
| div: { | ||
| _write: function(val, divider) { | ||
| return this.buffer.writeUInt8(val / divider); | ||
| } | ||
| }, | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'div(a)' } | ||
| ] | ||
| }); | ||
| buf = new Buffer 2 | ||
| types = bison.preCompile | ||
| div: | ||
| _write: (val, divider) -> @buffer.writeUInt8(val/divider) | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'div(a)'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 4, b: 8} | ||
| # buf will equal [ 0x04, 0x02 ] | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { a: 4, b: 8 }); | ||
| // buf will equal [ 0x04, 0x02 ] | ||
| ``` | ||
| ### Overriding a value | ||
| You can specify a specific value using the following syntax | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(2); | ||
| var types = bison.preCompile({ | ||
| 'my-type': [ | ||
| { a: 'uint8=1' }, | ||
| { b: 'uint8=2' } | ||
| ] | ||
| }); | ||
| buf = new Buffer 2 | ||
| types = bison.preCompile | ||
| my-type: [ | ||
| {a: 'uint8=1'} | ||
| {b: 'uint8=2'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', {} | ||
| # buf will equal [ 0x01, 0x02 ] | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', {}); | ||
| // buf will equal [ 0x01, 0x02 ] | ||
| ``` | ||
@@ -428,17 +444,26 @@ ### Arrays | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| buf = new Buffer 4 | ||
| types = bison.preCompile | ||
| object: [ | ||
| c: 'uint8' | ||
| ] | ||
| my-type: [ | ||
| {a: 'uint8'} | ||
| {b: 'object[a]'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { a: 3, b:[{c:1},{c:2},{c:3}] } | ||
| # buf will equal [ 0x03, 0x01, 0x02, 0x03 ] | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(4); | ||
| var types = bison.preCompile({ | ||
| object: [ | ||
| { c: 'uint8' } | ||
| ], | ||
| 'my-type': [ | ||
| { a: 'uint8' }, | ||
| { b: 'object[a]' } | ||
| ] | ||
| }); | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { | ||
| a: 3, | ||
| b: [ | ||
| { c: 1 }, | ||
| { c: 2 }, | ||
| { c: 3 } | ||
| ] | ||
| }); | ||
| // buf will equal [ 0x03, 0x01, 0x02, 0x03 ] | ||
| ``` | ||
@@ -448,17 +473,25 @@ ### Using an array length as a parameter | ||
| ```coffee | ||
| bison = require 'bison-types' | ||
| buf = new Buffer 4 | ||
| types = bison.preCompile | ||
| object: [ | ||
| c: 'uint8' | ||
| ] | ||
| my-type: [ | ||
| {a: 'uint8=b.length'} | ||
| {b: 'object[b.length]'} | ||
| ] | ||
| options = {bigEndian: false} | ||
| writer = new bison.Writer buf, types, options | ||
| writer.write 'my-type', { b:[{c:1},{c:2},{c:3}] } | ||
| # buf will equal [ 0x03, 0x01, 0x02, 0x03 ] | ||
| ```js | ||
| var bison = require('bison-types'); | ||
| var buf = Buffer.alloc(4); | ||
| var types = bison.preCompile({ | ||
| object: [ | ||
| { c: 'uint8' } | ||
| ], | ||
| 'my-type': [ | ||
| { a: 'uint8=b.length' }, | ||
| { b: 'object[b.length]' } | ||
| ] | ||
| }); | ||
| var writer = new bison.Writer(buf, types, { bigEndian: false }); | ||
| writer.write('my-type', { | ||
| b: [ | ||
| { c: 1 }, | ||
| { c: 2 }, | ||
| { c: 3 } | ||
| ] | ||
| }); | ||
| // buf will equal [ 0x03, 0x01, 0x02, 0x03 ] | ||
| ``` | ||
@@ -465,0 +498,0 @@ |
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Improved metrics
- Dependency count
2
-33.33%- Number of package files
11
10%- Number of lines in readme file
491
7.21%Worsened metrics
- Total package byte prevSize
23685
-7.16%- Dev dependency count
9
80%- Lines of code
309
-21.57%- Number of medium supply chain risk alerts
1
Infinity%Dependency changes
+ Added
clever-buffer@3.0.1(transitive)+ Added
debug@3.2.7(transitive)+ Added
ms@2.1.3(transitive)+ Added
node-addon-api@2.0.2(transitive)+ Added
ref-napi@1.4.3(transitive)- Removed
big.js@~3.1.3- Removed
big.js@3.1.3(transitive)- Removed
clever-buffer@2.1.0(transitive)- Removed
debug@2.6.9(transitive)- Removed
ms@2.0.0(transitive)- Removed
nan@2.22.2(transitive)- Removed
ref@1.3.4(transitive)Updated
clever-buffer@^3.0.0Updated
lodash@^4.17.15