TheThing/node-qrcode-lite
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor/core ()

Browse source 
* Split core lib into multiple files

* Refactor data encoding methods

* Refactor data masking process

* Improve qr code generation process

* Increase minimum required node version to 0.10

* Add linter

* Add tests and tests coverage

* Update travis config to fix compilation issues

* Add examples folder

* Add missing license tag in package.json

* Update build script and add sourcemap support

* Publish only strictly needed files on npm

* Update readme
This commit is contained in:
Vincenzo Greco 2016-12-16 23:45:08 +01:00 committed by GitHub
parent 7d57b052d4
commit 77064f5e5e
74 changed files with 3981 additions and 2554 deletions

3
.gitignore vendored
View file

@ -1,2 +1,5 @@
*~
node_modules
coverage
.nyc_output
build

1
.jshintignore
View file

@ -1 +0,0 @@
node_modules

18
.travis.yml
View file

@ -1,8 +1,20 @@
language: node_js
before_install:
- sudo apt-get update
- sudo apt-get install -y libgif-dev
node_js:
- "0.10"
- "0.12"
- "4.2.1"
env:
- CXX=g++-4.8
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-4.8
before_install:
- sudo apt-get update
- sudo apt-get install -y libgif-dev

264
README.md
View file

@ -1,176 +1,180 @@
[![Build Status](https://secure.travis-ci.org/soldair/node-qrcode.png)](http://travis-ci.org/soldair/node-qrcode)
[![Travis](https://img.shields.io/travis/soldair/node-qrcode.svg?style=flat-square)](http://travis-ci.org/soldair/node-qrcode)
[![npm](https://img.shields.io/npm/v/qrcode.svg?style=flat-square)](https://www.npmjs.com/package/qrcode)
[![npm](https://img.shields.io/npm/dt/qrcode.svg?style=flat-square)](https://www.npmjs.com/package/qrcode)
[![npm](https://img.shields.io/npm/l/qrcode.svg?style=flat-square)](https://github.com/soldair/node-qrcode/blob/master/license)
node-qrcode
=
This is a server side QR code/2d barcode generator.
# node-qrcode
> QR code/2d barcode generator.
It is an extension of "QRCode for JavaScript" which Kazuhiko Arase thankfully MIT licensed.
The `qrcode-draw.js` can be used directly as a client side lib if its appended too or included with `lib/qrcode.js`.
To use this on the server side please `require('qrcode');` =)
Examples
--------
A simple server side test...
```javascript
var QRCode = require('qrcode');
QRCode.toDataURL('i am a pony!',function(err,url){
console.log(url);
});
## Installation
Inside your project folder do:
```shell
npm install --save qrcode
```
In your terminal if you install globally...
or, install it globally to use `qrcode` from the command line to save qrcode images or generate ones you can view in your terminal.
```shell
npm install -g qrcode
```
## Dependencies
`node-canvas` is required.
(note: this dependency is only needed for server side use and will be likely removed in the future)
### Install node-canvas dependencies
`node-canvas` is a native module and requires dev packages of `Cairo` and `Pango` to compile.
Make sure to have these libs available on your system before run `npm install qrcode`
Installation instructions are available on [node-canvas](https://github.com/Automattic/node-canvas#installation) page.
## Usage
```shell
qrcode "hi i want a qrcode"
qrcode <text> [output file]
```
Output image format is detected from file extension.
Only `png` and `svg` format are supported for now.
qrcode "i like to save qrs to file" qr.png
If no output file is specified, the QR Code will be rendered directly in the terminal.
#### Example
```shell
qrcode "Draw a QR Code in my terminal"
```
```shell
qrcode "I like to save qrs as a PNG" qr.png
```
```shell
qrcode "I also like to save them as a SVG" qr.svg
```
In client side HTML...
## Client side
`node-qrcode` can be used in browser through [Browserify](https://github.com/substack/node-browserify), [Webpack](https://github.com/webpack/webpack) or by including the precompiled
bundle present in `build/` folder.
#### Browserify or Webpack
```html
<!--[if ie]><script type="text/javascript" src="/vendors/excanvas/excanvas.js"></script><![endif]-->
<script src="/build/qrcode.js"></script>
<canvas id="test"></canvas>
<script>
<!-- index.html -->
<html>
<body>
<canvas id="canvas"></canvas>
<script src="bundle.js"></script>
</body>
</html>
```
var qrcodedraw = new QRCodeLib.QRCodeDraw();
```javascript
// index.js -> bundle.js
var QRCode = require('qrcode')
var QRCodeDraw = new QRCode.QRCodeDraw()
var canvas = document.getElementById('canvas')
qrcodedraw.draw(document.getElementById('test'),"this text will be in the code!", function(error,canvas){
if(error){
return console.log('Error =( ',error);
}
QRCodeDraw.draw(canvas, 'sample text', function (error, canvas) {
if (error) console.error(error)
console.log('success!');
});
})
```
#### Precompiled bundle
```html
<canvas id="canvas"></canvas>
<script src="/build/qrcode.min.js"></script>
<script>
var qrcodedraw = new qrcodelib.qrcodedraw()
qrcodedraw.draw(document.getElementById('canvas'), 'sample text', function (error, canvas) {
if (error) console.error(error)
console.log('success!');
})
</script>
```
Remember to put `excanvas.js` and `qrcode.js` somewhere where your browser can find them.
Server Side API
---
```javascript
QRCode.draw(text, [optional options], cb(error,canvas));
```
Returns a node canvas object see https://github.com/LearnBoost/node-canvas for all of the cool node things you can do. Look up the canvas api for the other cool things.
```javascript
QRCode.toDataURL(text, [optional options], cb(error,dataURL));
Precompiled files are generated in `build/` folder during installation.
To manually rebuild the lib run:
```shell
npm run build
```
SVG output!
### Methods
```javascript
QRCode.drawSvg(text, [optional options],cb(error, svgString));
draw(canvasElement, text, [optional options], cb(error, canvas));
```
##### Options
```javascript
errorCorrectLevel
```
Can be one of the values in `QRCode.errorCorrectLevel`.
If `undefined`, defaults to H which is max error correction.
## Server side API
```javascript
QRCode.draw(text, [optional options], cb(error, canvas));
```
Returns a node canvas object see https://github.com/Automattic/node-canvas for all of the cool node things you can do. Look up the canvas api for the other cool things.
```javascript
QRCode.toDataURL(text, [optional options], cb(error, dataURL));
```
Returns mime image/png data url for the 2d barcode.
```javascript
QRCode.save(path, text, [optional options] , cb(error,written));
QRCode.drawSvg(text, [optional options], cb(error, svgString));
```
SVG output!
```javascript
QRCode.save(path, text, [optional options], cb(error, written));
```
Saves png to the path specified returns bytes written.
```javascript
QRCode.drawText(text, [optional options],cb)
```javascript
QRCode.drawText(text, [optional options], cb)
```
Returns an ascii representation of the qrcode using unicode characters and ansi control codes for background control.
```javascript
QRCode.drawBitArray(text, [optional options], cb(error,bits,width));
```javascript
QRCode.drawBitArray(text, [optional options], cb(error, bits, width));
```
Returns an array with each value being either 0 light or 1 dark and the width of each row.
This is enough info to render a qrcode any way you want. =)
##### Options
Options
---------
```javascript
errorCorrectLevel
```
Can be one of the values in `qrcode.errorCorrectLevel`.
Can be a string. one of `"minimum","medium","high","max"`.
Can be one of the values in `qrcode.errorCorrectLevel`.
Can be a string, one of `"minimum", "medium", "high", "max"`.
If `undefined`, defaults to H which is max error correction.
If invalid value, defaults to minimum error correction.
client side api
---------------
#### Example
```javascript
window.qrcodelib
```
`qrcodelib.qrcodedraw()` Constructor
```javascript
qrcode = new qrcodelib.qrcodedraw()
qrcode.draw(canvasElement,text,[optional options],cb);
var QRCode = require('qrcode')
QRCode.toDataURL('I am a pony!', function (err, url) {
console.log(url)
})
```
For quick client side use...
```shell
node test/clientsideserver.js
open http://localhost:3031
```
The JavaScript is in `test/clientside.html`.
## GS1 QR Codes
QR code capacity
---
This libary can encode this many bytes at each error correct level:
- 2953 in error correct level L
- 2331 in error correct level M
- 1663 in error correct level Q
- 1273 in error correct level H
The default is H.
please note as pointed out by @giacecco that byte length is often greater than string length due to multibyte characters.
```javascript
// so use the byte length
(new Buffer(str)).length
// instead of the string length
str.length
```
It can now be changed in an ugly way that wont be supported for more then another few days if you really need to. Also the default module size at qr version 40 is really too small for the camera on my Nexus 1 and to make it larger i run out of screen to show it. At 40 the barcode scanner even finds random UPC 1d barcodes in the mass of little squares.
the default module size cannot be changed through the public api at this time.
Installation
--
```shell
npm install qrcode
```
To use qrcode from the command line to save qrcode images or generate ones you can view in your terminal...
```shell
npm install -g qrcode
```
`node-canvas` is a native module and requires dev packages of `cairo` and `pixman` to compile.
On ubuntu you can install them with `apt-get` and `npm install` will work great.
```shell
sudo apt-get install libpixman-1-dev libcairo2-dev libpangocairo-1.0-0 libpango1.0-dev libgif-dev libjpeg-dev
```
i would like to switch to a js only image encoder to remove these deps.
Dependencies
------------
These should be taken care of for you by npm but you should...
```shell
npm install canvas
```
If `cairo` gives you trouble and you cannot install `canvas`, checkout the canvas site. I know @tjholowaychuk has setup a way to download and install a version of cairo/pixman for testing.
The word "QR Code" is registered trademark of:
DENSO WAVE INCORPORATED
GS1 qrcodes
-----------
there was a real good discussion here about them. but in short any qrcode generator will make gs1 compatable qrcodes, but what defines a gs1 qrcode is a header with metadata that describes your gs1 information.
There was a real good discussion here about them. but in short any qrcode generator will make gs1 compatable qrcodes, but what defines a gs1 qrcode is a header with metadata that describes your gs1 information.
https://github.com/soldair/node-qrcode/issues/45
## License
[MIT](https://github.com/soldair/node-qrcode/blob/master/license)
The word "QR Code" is registered trademark of:
DENSO WAVE INCORPORATED

40
bin/qrcode
View file

@ -1,30 +1,34 @@
#!/usr/bin/env node
try{
var qr = require('../qrcode.js');
} catch (e) {
qr = require('qrcode');
try {
var qr = require('../lib')
} catch (e) {
qr = require('qrcode')
}
var text = process.argv[2],
file = process.argv[3];
var text = process.argv[2]
var file = process.argv[3]
if (text && text.length) {
if(file && file.length){
qr.save(file,text,function(err,data){
if(!err) {
process.stdout.write("saved qrcode to: "+file+"\n");
if (file && file.length) {
qr.save(file, text, function (err, data) {
if (!err) {
process.stdout.write('saved qrcode to: ' + file + '\n')
} else {
process.stderr.write("failed to save qrcode\n");
throw err;
process.stderr.write('failed to save qrcode\n')
throw err
}
});
})
} else {
qr.drawText(text,function(error,text){
process.stdout.write(text);
process.stdout.write("\n");
});
qr.drawText(text, function (error, text) {
if (error) {
throw new Error(error)
}
process.stdout.write(text)
process.stdout.write('\n')
})
}
} else {
process.stderr.write("text\n\trequired as first argument.\nfile name [optional]\n\tto save png or svg qrcode may be provided as optional second argument\n");
process.stderr.write('text\n\trequired as first argument.\nfile name [optional]\n\tto save png or svg qrcode may be provided as optional second argument\n')
}

104
build.js
View file

@ -1,43 +1,67 @@
var spawn = require('child_process').spawn,
fs = require('fs');
var spawn = require('child_process').spawn
var fs = require('fs')
var q = [
function(){
var browserify = spawn('node',['node_modules/browserify/bin/cmd.js','qrcodeclient.js','-o', 'build/qrcode.js']);
browserify.stdin.end();
browserify.stdout.pipe(process.stdout);
browserify.stderr.pipe(process.stderr);
browserify.on('exit',function(code){
if(code){
console.error('browserify failed!');
process.exit(code);
}
done();
});
},
function(){
var uglify = spawn('node',['node_modules/uglify-js/bin/uglifyjs','build/qrcode.js']);
var minStream = fs.createWriteStream('build/qrcode.min.js');
uglify.stdout.pipe(minStream);
uglify.stdin.end();
uglify.on('exit',function(code){
if(code){
console.error('uglify failed!');
fs.unlink('build/qrcode.min.js',function(){
process.exit(code);
});
}
done();
});
}
],done = function(){
var j = q.shift();
if(j) j();
else complete()
},
complete = function(){
console.log('build complete =)');
};
function () {
if (!fs.existsSync('./build')) {
fs.mkdirSync('./build')
}
done();
done()
},
function () {
var browserify = spawn('node', [
'node_modules/.bin/browserify',
'lib/index.js',
'-s', 'qrcodelib',
'-d',
'-o', 'build/qrcode.js'
])
browserify.stdin.end()
browserify.stdout.pipe(process.stdout)
browserify.stderr.pipe(process.stderr)
browserify.on('exit', function (code) {
if (code) {
console.error('browserify failed!')
process.exit(code)
}
done()
})
},
function () {
var uglify = spawn('node', [
'node_modules/.bin/uglifyjs',
'--compress', '--mangle',
'--source-map', 'build/qrcode.min.js.map',
'--source-map-url', 'qrcode.min.js.map',
'--', 'build/qrcode.js'])
var minStream = fs.createWriteStream('build/qrcode.min.js')
uglify.stdout.pipe(minStream)
uglify.stdin.end()
uglify.on('exit', function (code) {
if (code) {
console.error('uglify failed!')
fs.unlink('build/qrcode.min.js', function () {
process.exit(code)
})
}
done()
})
}
]
var done = function () {
var j = q.shift()
if (j) j()
else complete()
}
var complete = function () {
console.log('build complete =)')
}
done()

0
build/.g
View file

9
examples/cli.js Normal file
View file

@ -0,0 +1,9 @@
var QRCode = require('../lib')
QRCode.drawText('yo yo yo', function (error, data) {
if (error) {
throw new Error(error)
}
console.log(data)
})

64
examples/clientside.html Normal file
View file

@ -0,0 +1,64 @@
<!doctype html>
<html>
<head>
<title>client side test for node-qrcode</title>
<!--[if ie]><script type="text/javascript" src="vendors/excanvas/excanvas.js"></script><![endif]-->
<script src="../build/qrcode.js"></script>
<style>.b{display:block;}</style>
</head>
<body>
<canvas id="test"></canvas>
<label for="test-text" class="b">type here and watch it update!:</label>
<textarea id="test-text" class="b"></textarea>
<small style="color:#d4d4d4;" class="b">* i did not include jquery on purpose</small>
<script>
if (!window.console) {
window.console = {
log: function () {},
warn: function () {}
}
}
var qrcodedraw = new qrcodelib.qrcodedraw()
var drawQR = function (text) {
qrcodedraw.draw(document.getElementById('test'), text, {
version: 0,
errorCorrectLevel: qrcodedraw.QRErrorCorrectLevel.L
}, function (error, canvas) {
if (error) {
if (window.console && window.console.warn) {
console.warn(error)
} else {
window.alert(error)
}
}
})
}
var ta = document.getElementById('test-text')
var last = 0
var lastTime = 1
ta.addEventListener('keyup', function () {
var l = Date.now()
var z = this
last = l
setTimeout(function () {
// this will kinda lock the browsers event loop for a sec.
// it could have some setTimeout within processing to make it more client side friendly. or web workers...
if (l === last) {
var s = Date.now()
drawQR(z.value)
lastTime = Date.now() - s
}
}, lastTime + (lastTime / 2))
}, false)
ta.value = 'i work client side too?'
drawQR('i work client side too?')
</script>
</body>
</html>

319
examples/clientsideserver.js Normal file
View file

@ -0,0 +1,319 @@
var express = require('express')
var app = express.createServer()
var http = require('http')
var fs = require('fs')
var QRCode = require('../lib')
var canvasutil = require('canvasutil')
var Canvas = require('canvas')
var Image = Canvas.Image
var path = require('path')
app.configure(function () {
app.use(express.methodOverride())
app.use(express.bodyParser())
app.use(app.router)
app.use(express.static(path.resolve(__dirname, '..')))
})
app.get('/', function (req, res) {
fs.readFile(path.join(__dirname, 'clientside.html'), function (err, data) {
res.send(data ? data.toString() : err)
})
})
var effectHandlers = {}
app.get('/generate', function (req, res) {
var q = req.query || {}
QRCode.QRCodeDraw.color.light = q.lightColor || '#ffffff'
QRCode.QRCodeDraw.color.dark = q.darkColor || '#000000'
QRCode.QRCodeDraw.scale = +(q.scale)
if (isNaN(QRCode.QRCodeDraw.scale)) QRCode.QRCodeDraw.scale = 4
// NOTE when i set scale to 500 something seg faulted
if (QRCode.QRCodeDraw.scale > 50) QRCode.QRCodeDraw.scale = 50
var effect = q.effect || 'plain'
if (!effectHandlers[effect]) {
effect = 'plain'
}
effectHandlers[effect](q, function (error, canvas) {
if (!error) {
canvas.toBuffer(function (err, buf) {
if (!err) {
res.header('Content-Type', 'image/png')
res.send(buf)
}
})
} else {
var msg = error.message + '\n' + error.stack
res.header('Content-Type', 'text/plain')
res.send(msg)
console.error(msg)
}
})
})
effectHandlers.node = function (args, cb) {
args.src = path.join(__dirname, 'images', 'node_logo.png')
this.image(path.join(args, cb))
}
effectHandlers.npm = function (args, cb) {
args.src = path.join(__dirname, 'images', 'npm_logo.png')
this.image(args, cb)
}
effectHandlers.bacon = function (args, cb) {
args.src = path.join(__dirname, 'images', 'bacon-love.png')
this.image(args, cb)
}
effectHandlers.baconBikini = function (args, cb) {
args.src = path.join(__dirname, 'images', 'bacon-bikini.png')
this.image(args, cb)
}
effectHandlers.rounded = function (args, cb) {
QRCode.draw(args.text || '', function (err, canvas) {
if (err) {
cb(err, canvas)
return
}
var tpx = new canvasutil.PixelCore()
var luma709Only = canvasutil.conversionLib.luma709Only
var up = []
var down = []
var left = []
var right = []
var upPx
var downPx
var leftPx
var rightPx
var r
var t
var l
var d
var corner = 0
tpx.threshold = 100
tpx.iterate(canvas, function (px, i, len, pixels, w, h, pixelCore) {
corner = 0
// is dark
if (luma709Only(px.r, px.g, px.b) < pixelCore.threshold) {
if (i - w > 0) {
upPx = (i - w) * 4
up[0] = pixels[upPx + 0]
up[1] = pixels[upPx + 1]
up[2] = pixels[upPx + 2]
// console.log('up',up);
}
if (i + w <= len) {
downPx = (i + w) * 4
down[0] = pixels[downPx + 0]
down[1] = pixels[downPx + 1]
down[2] = pixels[downPx + 2]
// console.log('down',down);
}
// have left pixel but no wrapping
if (i % w !== 0) {
leftPx = (i - 1) * 4
left[0] = pixels[leftPx + 0]
left[1] = pixels[leftPx + 1]
left[2] = pixels[leftPx + 2]
// console.log('left',left);
}
if (i % w !== w - 1) {
rightPx = (i + 1) * 4
right[0] = pixels[rightPx + 0]
right[1] = pixels[rightPx + 1]
right[2] = pixels[rightPx + 2]
// console.log('right',right);
}
r = rightPx ? luma709Only(right[0], right[1], right[2]) : 0
t = upPx ? luma709Only(up[0], up[1], up[2]) : 0
l = leftPx ? luma709Only(left[0], left[1], left[2]) : 0
d = downPx ? luma709Only(down[0], down[1], down[2]) : 0
if (l > pixelCore.threshold) { // if left is light and i am dark
if (t > pixelCore.threshold) { // if top is light and i am dark
corner = 1
pixels[rightPx + 4] = 100
} else if (d > pixelCore.threshold) { // if bottom is light and i am dark
pixels[rightPx + 4] = 100
corner = 1
}
} else if (r > pixelCore.threshold) {
if (t > pixelCore.threshold) { // if top is light and i am dark
corner = 1
} else if (d > pixelCore.threshold) { // if bottom is light and i am dark
corner = 1
}
}
if (corner) {
px.a = 50
}
}
})
cb(false, canvas)
})
}
effectHandlers.remoteImage = function (args, cb) {
var src = args.src
var domain
var uri
if (!src) {
cb(new Error('src required'), null)
} else {
if (src.indexof('://') !== -1) {
src = src.split('://').unshift()
var parts = src.split('/')
domain = parts.shift()
uri = parts.join('/')
}
}
if (!domain || !uri) {
cb(new Error('missing domain or uri ' + args.src))
return
}
var options = {
host: domain,
port: 80,
path: uri,
method: 'GET'
}
var req = http.request(options, function (res) {
if (res.statusCode < 200 || res.statusCode > 299) {
cb(new Error('http ' + res.statusCode + ' response code'), null)
return
}
res.setEncoding('utf8')
var data = ''
res.on('data', function (chunk) {
data += chunk
console.log('BODY: ' + chunk)
})
res.on('complete', function () {
cb(false, data)
})
res.on('error', function (error) {
cb(error, null)
cb = function () {}
})
})
req.end()
}
effectHandlers.image = function (args, cb) {
var src = args.src || ''
var img = new Image()
var convert = canvasutil.conversionLib
img.onload = function () {
QRCode.draw(args.text || '', function (err, canvas) {
if (err) {
cb(err, false)
return
}
var codeCtx = canvas.getContext('2d')
var frame = codeCtx.getImageData(0, 0, canvas.width, canvas.width)
var tpx = new canvasutil.PixelCore()
var baconCanvas = new Canvas(canvas.width, canvas.width)
var ctx = baconCanvas.getContext('2d')
var topThreshold = args.darkThreshold || 25
var bottomThreshold = args.lightThreshold || 75
tpx.threshold = 50
// scale image
var w = canvas.width
var h = canvas.height
if (img.width > img.height) {
w = w * (canvas.height / h)
h = canvas.height
} else {
h = h * (canvas.height / w)
w = canvas.width
}
ctx.drawImage(img, 0, 0, w, h)
try {
tpx.iterate(baconCanvas, function (px, i, l, pixels, w, h, pixelCore) {
var luma = (0.2125 * px.r + 0.7154 * px.g + 0.0721 * px.b)
var codeLuma = convert.luma709Only(frame.data[i * 4], frame.data[i * 4 + 1], frame.data[i * 4 + 2])
var yuv
var rgb
if (codeLuma > pixelCore.threshold) {
if (luma < bottomThreshold) {
yuv = convert.rgbToYuv(px.r, px.g, px.b)
rgb
rgb = convert.yuvToRgb(bottomThreshold, yuv[1], yuv[2])
px.r = rgb[0]
px.g = rgb[1]
px.b = rgb[2]
px.a = 255
}
} else {
if (luma > topThreshold) {
yuv = convert.rgbToYuv(px.r, px.g, px.b)
rgb = convert.yuvToRgb(topThreshold, yuv[1], yuv[2])
px.r = rgb[0]
px.g = rgb[1]
px.b = rgb[2]
}
}
})
} catch (e) {
cb(err, false)
}
cb(false, baconCanvas)
})
}
img.onerror = function (error) {
error.message += ' (' + src + ')'
cb(error, null)
}
img.src = src
}
effectHandlers.plain = function (args, cb) {
var text = args.text || ''
QRCode.draw(text || '', function (err, canvas) {
cb(err, canvas)
})
}
app.listen(3031)
console.log('listening on 3031')

0
test/fixtures/bacon-bikini.png → examples/images/bacon-bikini.png
View file

Side by side Swipe Overlay

Before

(image error) Size: 398 KiB

After

(image error) Size: 398 KiB

0
test/fixtures/bacon-love.png → examples/images/bacon-love.png
View file

Side by side Swipe Overlay

Before

(image error) Size: 211 KiB

After

(image error) Size: 211 KiB

14
examples/save.js Normal file
View file

@ -0,0 +1,14 @@
var QRCode = require('../lib')
var fs = require('fs')
var util = require('util')
var path = './tmp.png'
QRCode.save(path, 'life of the party bros', function (error, written) {
if (error) {
console.log(error)
} else {
util.print(written === (fs.statSync(path) || {}).size ? 'PASS: written should be to the correct file\n' : 'FAIL: file should be written size\n')
fs.unlinkSync(path)
}
})

35
examples/server.js Normal file
View file

@ -0,0 +1,35 @@
var QRCode = require('../lib')
var connect = require('express')
function testQRCode (req, res) {
res.writeHead(200, { 'Content-Type': 'text/html' })
var jungleBook = "The moonlight was blocked out of the mouth of the cave, for Shere Khan's\n" +
'great square head and shoulders were thrust into the entrance. Tabaqui,\n' +
'behind him, was squeaking: "My lord, my lord, it went in here!"\n' +
'\n' +
'"Shere Khan does us great honor," said Father Wolf, but his eyes were\n' +
'very angry. "What does Shere Khan need?"\n' +
'\n' +
"\"My quarry. A man's cub went this way,\" said Shere Khan. \"Its parents\n" +
'have run off. Give it to me."\n' +
'\n' +
"Shere Khan had jumped at a woodcutter's campfire, as Father Wolf had\n" +
'said, and was furious from the pain of his burned feet. But Father Wolf\n' +
'knew that the mouth of the cave was too narrow for a tiger to come in\n' +
"by. Even where he was, Shere Khan's shoulders and forepaws were cramped\n" +
"for want of room, as a man's would be if he tried to fight in a barrel.\n" +
'\n' +
'"The Wolves are a free people," said Father Wolf. "They take orders from\n' +
"the Head of the Pack, and not from any striped cattle-killer. The man's\n" +
'cub is ours--to kill if we choose."'
// QRCode.QRCodeDraw.color.dark = '#d4d4d4';
QRCode.toDataURL(jungleBook, function (err, url) {
if (err) console.log('error: ' + err)
res.end("<!DOCTYPE html/><html><head><title>node-qrcode</title></head><body><img src='" + url + "'/></body></html>")
})
}
connect.createServer(testQRCode).listen(3030)
console.log('test server started on port 3030')

0
vendors/excanvas/README → examples/vendors/excanvas/README vendored
View file

0
vendors/excanvas/excanvas.compiled.js → examples/vendors/excanvas/excanvas.compiled.js vendored
View file

0
vendors/excanvas/excanvas.js → examples/vendors/excanvas/excanvas.js vendored
View file

7
lib/browser.js Normal file
View file

@ -0,0 +1,7 @@
var QRCodeLib = require('./renderer/qrcode-draw.js')
// monkey patch old api
QRCodeLib.qrcodedraw = QRCodeLib.QRCodeDraw
module.exports = QRCodeLib

83
lib/core/alignment-pattern.js Normal file
View file

@ -0,0 +1,83 @@
/**
* Alignment pattern are fixed reference pattern in defined positions
* in a matrix symbology, which enables the decode software to re-synchronise
* the coordinate mapping of the image modules in the event of moderate amounts
* of distortion of the image.
*
* Alignment patterns are present only in QR Code symbols of version 2 or larger
* and their number depends on the symbol version.
*/
var getSymbolSize = require('./utils').getSymbolSize
/**
* Calculate the row/column coordinates of the center module of each alignment pattern
* for the specified QR Code version.
*
* The alignment patterns are positioned symmetrically on either side of the diagonal
* running from the top left corner of the symbol to the bottom right corner.
*
* Since positions are simmetrical only half of the coordinates are returned.
* Each item of the array will represent in turn the x and y coordinate.
* @see {@link getPositions}
*
* @param {Number} version QR Code version
* @return {Array} Array of coordinate
*/
exports.getRowColCoords = function getRowColCoords (version) {
if (version === 1) return []
var posCount = Math.floor(version / 7) + 2
var size = getSymbolSize(version)
var intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2
var positions = [size - 7] // Last coord is always (size - 7)
for (var i = 1; i < posCount - 1; i++) {
positions[i] = positions[i - 1] - intervals
}
positions.push(6) // First coord is always 6
return positions.reverse()
}
/**
* Returns an array containing the positions of each alignment pattern.
* Each array's element represent the center point of the pattern as (x, y) coordinates
*
* Coordinates are calculated expanding the row/column coordinates returned by {@link getRowColCoords}
* and filtering out the items that overlaps with finder pattern
*
* @example
* For a Version 7 symbol {@link getRowColCoords} returns values 6, 22 and 38.
* The alignment patterns, therefore, are to be centered on (row, column)
* positions (6,22), (22,6), (22,22), (22,38), (38,22), (38,38).
* Note that the coordinates (6,6), (6,38), (38,6) are occupied by finder patterns
* and are not therefore used for alignment patterns.
*
* var pos = getPositions(7)
* // [[6,22], [22,6], [22,22], [22,38], [38,22], [38,38]]
*
* @param {Number} version QR Code version
* @return {Array} Array of coordinates
*/
exports.getPositions = function getPositions (version) {
var coords = []
var pos = exports.getRowColCoords(version)
var posLength = pos.length
for (var i = 0; i < posLength; i++) {
for (var j = 0; j < posLength; j++) {
// Skip if position is occupied by finder patterns
if (i === 0 && j === 0 || // top-left
i === 0 && j === posLength - 1 || // bottom-left
i === posLength - 1 && j === 0) { // top-right
continue
}
coords.push([pos[i], pos[j]])
}
}
return coords
}

37
lib/core/bit-buffer.js Normal file
View file

@ -0,0 +1,37 @@
function BitBuffer () {
this.buffer = []
this.length = 0
}
BitBuffer.prototype = {
get: function (index) {
var bufIndex = Math.floor(index / 8)
return ((this.buffer[bufIndex] >>> (7 - index % 8)) & 1) === 1
},
put: function (num, length) {
for (var i = 0; i < length; i++) {
this.putBit(((num >>> (length - i - 1)) & 1) === 1)
}
},
getLengthInBits: function () {
return this.length
},
putBit: function (bit) {
var bufIndex = Math.floor(this.length / 8)
if (this.buffer.length <= bufIndex) {
this.buffer.push(0)
}
if (bit) {
this.buffer[bufIndex] |= (0x80 >>> (this.length % 8))
}
this.length++
}
}
module.exports = BitBuffer

69
lib/core/bit-matrix.js Normal file
View file

@ -0,0 +1,69 @@
var Buffer = require('../utils/buffer')
/**
* Helper class to handle QR Code symbol modules
*
* @param {Number} size Symbol size
*/
function BitMatrix (size) {
if (!size || size < 1) {
throw new Error('BitMatrix size must be defined and greater than 0')
}
this.size = size
this.data = new Buffer(size * size)
this.data.fill(0)
this.reservedBit = new Buffer(size * size)
this.reservedBit.fill(0)
}
/**
* Set bit value at specified location
* If reserved flag is set, this bit will be ignored during masking process
*
* @param {Number} row
* @param {Number} col
* @param {Boolean} value
* @param {Boolean} reserved
*/
BitMatrix.prototype.set = function (row, col, value, reserved) {
var index = row * this.size + col
this.data[index] = value
if (reserved) this.reservedBit[index] = true
}
/**
* Returns bit value at specified location
*
* @param {Number} row
* @param {Number} col
* @return {Boolean}
*/
BitMatrix.prototype.get = function (row, col) {
return this.data[row * this.size + col]
}
/**
* Applies xor operator at specified location
* (used during masking process)
*
* @param {Number} row
* @param {Number} col
* @param {Boolean} value
*/
BitMatrix.prototype.xor = function (row, col, value) {
this.data[row * this.size + col] ^= value
}
/**
* Check if bit at specified location is reserved
*
* @param {Number} row
* @param {Number} col
* @return {Boolean}
*/
BitMatrix.prototype.isReserved = function (row, col) {
return this.reservedBit[row * this.size + col]
}
module.exports = BitMatrix

40
lib/core/byte-data.js Normal file
View file

@ -0,0 +1,40 @@
var Buffer = require('../utils/buffer')
var Mode = require('./mode')
function ByteData (data) {
this.mode = Mode.BYTE
this.data = new Buffer(data)
}
ByteData.getCharCountIndicator = function getCharCountIndicator (version) {
if (version >= 1 && version < 10) {
// 1 - 9
return 8
} else if (version >= 10 && version < 41) {
// 10 - 40
return 16
} else {
throw new Error('version: ' + version)
}
}
ByteData.prototype = {
getLength: function (buffer) {
return this.data.length
},
append: function (data) {
this.data = Buffer.concat([this.data, new Buffer(data)])
return this
},
write: function (buffer) {
for (var i = 0, l = this.data.length; i < l; i++) {
buffer.put(this.data[i], 8)
}
},
getCharCountIndicator: ByteData.getCharCountIndicator
}
module.exports = ByteData

135
lib/core/error-correction-code.js Executable file
View file

@ -0,0 +1,135 @@
var ECLevel = require('./error-correction-level')
var EC_BLOCKS_TABLE = [
// L M Q H
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 2, 2,
1, 2, 2, 4,
1, 2, 4, 4,
2, 4, 4, 4,
2, 4, 6, 5,
2, 4, 6, 6,
2, 5, 8, 8,
4, 5, 8, 8,
4, 5, 8, 11,
4, 8, 10, 11,
4, 9, 12, 16,
4, 9, 16, 16,
6, 10, 12, 18,
6, 10, 17, 16,
6, 11, 16, 19,
6, 13, 18, 21,
7, 14, 21, 25,
8, 16, 20, 25,
8, 17, 23, 25,
9, 17, 23, 34,
9, 18, 25, 30,
10, 20, 27, 32,
12, 21, 29, 35,
12, 23, 34, 37,
12, 25, 34, 40,
13, 26, 35, 42,
14, 28, 38, 45,
15, 29, 40, 48,
16, 31, 43, 51,
17, 33, 45, 54,
18, 35, 48, 57,
19, 37, 51, 60,
19, 38, 53, 63,
20, 40, 56, 66,
21, 43, 59, 70,
22, 45, 62, 74,
24, 47, 65, 77,
25, 49, 68, 81
]
var EC_CODEWORDS_TABLE = [
// L M Q H
7, 10, 13, 17,
10, 16, 22, 28,
15, 26, 36, 44,
20, 36, 52, 64,
26, 48, 72, 88,
36, 64, 96, 112,
40, 72, 108, 130,
48, 88, 132, 156,
60, 110, 160, 192,
72, 130, 192, 224,
80, 150, 224, 264,
96, 176, 260, 308,
104, 198, 288, 352,
120, 216, 320, 384,
132, 240, 360, 432,
144, 280, 408, 480,
168, 308, 448, 532,
180, 338, 504, 588,
196, 364, 546, 650,
224, 416, 600, 700,
224, 442, 644, 750,
252, 476, 690, 816,
270, 504, 750, 900,
300, 560, 810, 960,
312, 588, 870, 1050,
336, 644, 952, 1110,
360, 700, 1020, 1200,
390, 728, 1050, 1260,
420, 784, 1140, 1350,
450, 812, 1200, 1440,
480, 868, 1290, 1530,
510, 924, 1350, 1620,
540, 980, 1440, 1710,
570, 1036, 1530, 1800,
570, 1064, 1590, 1890,
600, 1120, 1680, 1980,
630, 1204, 1770, 2100,
660, 1260, 1860, 2220,
720, 1316, 1950, 2310,
750, 1372, 2040, 2430
]
/**
* Returns the number of error correction block that the QR Code should contain
* for the specified version and error correction level.
*
* @param {Number} version QR Code version
* @param {Number} errorCorrectionLevel Error correction level
* @return {Number} Number of error correction blocks
*/
exports.getBlocksCount = function getBlocksCount (version, errorCorrectionLevel) {
switch (errorCorrectionLevel) {
case ECLevel.L:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 0]
case ECLevel.M:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 1]
case ECLevel.Q:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 2]
case ECLevel.H:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 3]
default:
return undefined
}
}
/**
* Returns the number of error correction codewords to use for the specified
* version and error correction level.
*
* @param {Number} version QR Code version
* @param {Number} errorCorrectionLevel Error correction level
* @return {Number} Number of error correction codewords
*/
exports.getTotalCodewordsCount = function getTotalCodewordsCount (version, errorCorrectionLevel) {
switch (errorCorrectionLevel) {
case ECLevel.L:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 0]
case ECLevel.M:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 1]
case ECLevel.Q:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 2]
case ECLevel.H:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 3]
default:
return undefined
}
}

6
lib/core/error-correction-level.js Normal file
View file

@ -0,0 +1,6 @@
module.exports = {
L: 1,
M: 0,
Q: 3,
H: 2
}

22
lib/core/finder-pattern.js Normal file
View file

@ -0,0 +1,22 @@
var getSymbolSize = require('./utils').getSymbolSize
var FINDER_PATTERN_SIZE = 7
/**
* Returns an array containing the positions of each finder pattern.
* Each array's element represent the top-left point of the pattern as (x, y) coordinates
*
* @param {Number} version QR Code version
* @return {Array} Array of coordinates
*/
exports.getPositions = function getPositions (version) {
var size = getSymbolSize(version)
return [
// top-left
[0, 0],
// top-right
[size - FINDER_PATTERN_SIZE, 0],
// bottom-left
[0, size - FINDER_PATTERN_SIZE]
]
}

29
lib/core/format-info.js Normal file
View file

@ -0,0 +1,29 @@
var Utils = require('./utils')
var G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0)
var G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1)
var G15_BCH = Utils.getBCHDigit(G15)
/**
* Returns format information with relative error correction bits
*
* The format information is a 15-bit sequence containing 5 data bits,
* with 10 error correction bits calculated using the (15, 5) BCH code.
*
* @param {Number} errorCorrectionLevel Error correction level
* @param {Number} mask Mask pattern
* @return {Number} Encoded format information bits
*/
exports.getEncodedBits = function getEncodedBits (errorCorrectionLevel, mask) {
var data = ((errorCorrectionLevel << 3) | mask)
var d = data << 10
while (Utils.getBCHDigit(d) - G15_BCH >= 0) {
d ^= (G15 << (Utils.getBCHDigit(d) - G15_BCH))
}
// xor final data with mask pattern in order to ensure that
// no combination of Error Correction Level and data mask pattern
// will result in an all-zero data string
return ((data << 10) | d) ^ G15_MASK
}

72
lib/core/galois-field.js Normal file
View file

@ -0,0 +1,72 @@
var Buffer = require('../utils/buffer')
var EXP_TABLE = new Buffer(512)
var LOG_TABLE = new Buffer(256)
/**
* Precompute the log and anti-log tables for faster computation later
*
* For each possible value in the galois field 2^8, we will pre-compute
* the logarithm and anti-logarithm (exponential) of this value
*
* ref {@link https://en.wikiversity.org/wiki/Reed%E2%80%93Solomon_codes_for_coders#Introduction_to_mathematical_fields}
*/
;(function initTables () {
var x = 1
for (var i = 0; i < 255; i++) {
EXP_TABLE[i] = x
LOG_TABLE[x] = i
x <<= 1 // multiply by 2
// The QR code specification says to use byte-wise modulo 100011101 arithmetic.
// This means that when a number is 256 or larger, it should be XORed with 0x11D.
if (x & 0x100) { // similar to x >= 256, but a lot faster (because 0x100 == 256)
x ^= 0x11D
}
}
// Optimization: double the size of the anti-log table so that we don't need to mod 255 to
// stay inside the bounds (because we will mainly use this table for the multiplication of
// two GF numbers, no more).
// @see {@link mul}
for (i = 255; i < 512; i++) {
EXP_TABLE[i] = EXP_TABLE[i - 255]
}
}())
/**
* Returns log value of n inside Galois Field
*
* @param {Number} n
* @return {Number}
*/
exports.log = function log (n) {
if (n < 1) throw new Error('log(' + n + ')')
return LOG_TABLE[n]
}
/**
* Returns anti-log value of n inside Galois Field
*
* @param {Number} n
* @return {Number}
*/
exports.exp = function exp (n) {
return EXP_TABLE[n]
}
/**
* Multiplies two number inside Galois Field
*
* @param {Number} x
* @param {Number} y
* @return {Number}
*/
exports.mul = function mul (x, y) {
if (x === 0 || y === 0) return 0
// should be EXP_TABLE[(LOG_TABLE[x] + LOG_TABLE[y]) % 255] if EXP_TABLE wasn't oversized
// @see {@link initTables}
return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]]
}

221
lib/core/mask-pattern.js Normal file
View file

@ -0,0 +1,221 @@
/**
* Data mask pattern reference
* @type {Object}
*/
exports.Patterns = {
PATTERN000: 0,
PATTERN001: 1,
PATTERN010: 2,
PATTERN011: 3,
PATTERN100: 4,
PATTERN101: 5,
PATTERN110: 6,
PATTERN111: 7
}
/**
* Weighted penalty scores for the undesirable features
* @type {Object}
*/
var PenalityScores = {
N1: 3,
N2: 3,
N3: 40,
N4: 10
}
/**
* Find adjacent modules in row/column with the same color
* and assign a penality value.
*
* Points: N1 + i
* i is the amount by which the number of adjacent modules of the same color exceeds 5
*/
function getPenalityN1 (data) {
var size = data.size
var points = 0
for (var row = 0; row < size; row++) {
for (var col = 0; col < size; col++) {
// number of consecutive modules with same color
var sameCount = 0
var dark = data.get(row, col)
for (var r = -1; r <= 1; r++) {
if (row + r < 0 || size <= row + r) continue
for (var c = -1; c <= 1; c++) {
if (col + c < 0 || size <= col + c) continue
if (r === 0 && c === 0) continue
if (dark === data.get(row + r, col + c)) sameCount++
}
}
if (sameCount > 5) {
points += PenalityScores.N1 + sameCount - 5
}
}
}
return points
}
/**
* Find 2x2 blocks with the same color and assign a penality value
*
* Points: N2 * (m - 1) * (n - 1)
*/
function getPenalityN2 (data) {
var size = data.size
var points = 0
for (var row = 0; row < size - 1; row++) {
for (var col = 0; col < size - 1; col++) {
var count = 0
if (data.get(row, col)) count++
if (data.get(row + 1, col)) count++
if (data.get(row, col + 1)) count++
if (data.get(row + 1, col + 1)) count++
if (count === 0 || count === 4) points += PenalityScores.N2
}
}
return points
}
/**
* Find 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column,
* preceded or followed by light area 4 modules wide
*
* Points: N3 * number of pattern found
*/
function getPenalityN3 (data) {
var size = data.size
var points = 0
var row, col
for (row = 0; row < size; row++) {
for (col = 0; col < size - 6; col++) {
if (data.get(row, col) &&
!data.get(row, col + 1) &&
data.get(row, col + 2) &&
data.get(row, col + 3) &&
data.get(row, col + 4) &&
!data.get(row, col + 5) &&
data.get(row, col + 6)) {
points += PenalityScores.N3
}
}
}
for (col = 0; col < size; col++) {
for (row = 0; row < size - 6; row++) {
if (data.get(row, col) &&
!data.get(row + 1, col) &&
data.get(row + 2, col) &&
data.get(row + 3, col) &&
data.get(row + 4, col) &&
!data.get(row + 5, col) &&
data.get(row + 6, col)) {
points += PenalityScores.N3
}
}
}
return points
}
/**
* Calculate proportion of dark modules in entire symbol
*
* Points: N4 * k
*
* k is the rating of the deviation of the proportion of dark modules
* in the symbol from 50% in steps of 5%
*/
function getPenalityN4 (data) {
var darkCount = 0
var size = data.size
for (var col = 0; col < size; col++) {
for (var row = 0; row < size; row++) {
if (data.get(row, col)) darkCount++
}
}
var ratio = Math.abs(100 * darkCount / size / size - 50) / 5
return ratio * PenalityScores.N4
}
/**
* Return mask value at given position
*
* @param {Number} maskPattern Pattern reference value
* @param {Number} i Row
* @param {Number} j Column
* @return {Boolean} Mask value
*/
function getMaskAt (maskPattern, i, j) {
switch (maskPattern) {
case exports.Patterns.PATTERN000: return (i + j) % 2 === 0
case exports.Patterns.PATTERN001: return i % 2 === 0
case exports.Patterns.PATTERN010: return j % 3 === 0
case exports.Patterns.PATTERN011: return (i + j) % 3 === 0
case exports.Patterns.PATTERN100: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0
case exports.Patterns.PATTERN101: return (i * j) % 2 + (i * j) % 3 === 0
case exports.Patterns.PATTERN110: return ((i * j) % 2 + (i * j) % 3) % 2 === 0
case exports.Patterns.PATTERN111: return ((i * j) % 3 + (i + j) % 2) % 2 === 0
default: throw new Error('bad maskPattern:' + maskPattern)
}
}
/**
* Apply a mask pattern to a BitMatrix
*
* @param {Number} pattern Pattern reference number
* @param {BitMatrix} data BitMatrix data
*/
exports.applyMask = function applyMask (pattern, data) {
var size = data.size
for (var col = 0; col < size; col++) {
for (var row = 0; row < size; row++) {
if (data.isReserved(row, col)) continue
data.xor(row, col, getMaskAt(pattern, row, col))
}
}
}
/**
* Returns the best mask pattern for data
*
* @param {BitMatrix} data
* @return {Number} Mask pattern reference number
*/
exports.getBestMask = function getBestMask (data) {
var numPatterns = Object.keys(exports.Patterns).length
var bestPattern = 0
var lowerPenality = Infinity
for (var p = 0; p < numPatterns; p++) {
exports.applyMask(p, data)
// Calculate penality
var penality =
getPenalityN1(data) +
getPenalityN2(data) +
getPenalityN3(data) +
getPenalityN4(data)
// Undo previously applied mask
exports.applyMask(p, data)
if (penality < lowerPenality) {
lowerPenality = penality
bestPattern = p
}
}
return bestPattern
}

34
lib/core/mode.js Normal file
View file

@ -0,0 +1,34 @@
/**
* Data modes
*
* @type {Object}
*/
module.exports = {
/**
* Numeric mode encodes data from the decimal digit set (0 - 9) (byte values 30HEX to 39HEX).
* Normally, 3 data characters are represented by 10 bits.
*/
NUMERIC: 1 << 0,
/**
* Alphanumeric mode encodes data from a set of 45 characters,
* i.e. 10 numeric digits (0 - 9),
* 26 alphabetic characters (A - Z),
* and 9 symbols (SP, $, %, *, +, -, ., /, :).
* Normally, two input characters are represented by 11 bits.
*/
ALPHA_NUM: 1 << 1,
/**
* In byte mode, data is encoded at 8 bits per character.
*/
BYTE: 1 << 2,
/**
* The Kanji mode efficiently encodes Kanji characters in accordance with the Shift JIS system
* based on JIS X 0208. The Shift JIS values are shifted from the JIS X 0208 values.
* JIS X 0208 gives details of the shift coded representation.
* Each two-byte character value is compacted to a 13-bit binary codeword.
*/
KANJI: 1 << 3
}

64
lib/core/polynomial.js Normal file
View file

@ -0,0 +1,64 @@
var Buffer = require('../utils/buffer')
var GF = require('./galois-field')
/**
* Multiplies two polynomials inside Galois Field
*
* @param {Buffer} p1 Polynomial
* @param {Buffer} p2 Polynomial
* @return {Buffer} Product of p1 and p2
*/
exports.mul = function mul (p1, p2) {
var coeff = new Buffer(p1.length + p2.length - 1)
coeff.fill(0)
for (var i = 0; i < p1.length; i++) {
for (var j = 0; j < p2.length; j++) {
coeff[i + j] ^= GF.mul(p1[i], p2[j])
}
}
return coeff
}
/**
* Calculate the remainder of polynomials division
*
* @param {Buffer} divident Polynomial
* @param {Buffer} divisor Polynomial
* @return {Buffer} Remainder
*/
exports.mod = function mod (divident, divisor) {
var result = new Buffer(divident)
while ((result.length - divisor.length) >= 0) {
var coeff = result[0]
for (var i = 0; i < divisor.length; i++) {
result[i] ^= GF.mul(divisor[i], coeff)
}
// remove all zeros from buffer head
var offset = 0
while (offset < result.length && result[offset] === 0) offset++
result = result.slice(offset)
}
return result
}
/**
* Generate an irreducible generator polynomial of specified degree
* (used by Reed-Solomon encoder)
*
* @param {Number} degree Degree of the generator polynomial
* @return {Buffer} Buffer containing polynomial coefficients
*/
exports.generateECPolynomial = function generateECPolynomial (degree) {
var poly = new Buffer([1])
for (var i = 0; i < degree; i++) {
poly = exports.mul(poly, [1, GF.exp(i)])
}
return poly
}

494
lib/core/qrcode.js Normal file
View file

@ -0,0 +1,494 @@
var Buffer = require('../utils/buffer')
var Utils = require('./utils')
var ECLevel = require('./error-correction-level')
var ByteData = require('./byte-data')
var BitBuffer = require('./bit-buffer')
var BitMatrix = require('./bit-matrix')
var AlignmentPattern = require('./alignment-pattern')
var FinderPattern = require('./finder-pattern')
var MaskPattern = require('./mask-pattern')
var ECCode = require('./error-correction-code')
var ReedSolomonEncoder = require('./reed-solomon-encoder')
var Version = require('./version')
var FormatInfo = require('./format-info')
/**
* QRCode for JavaScript
*
* modified by Ryan Day for nodejs support
* Copyright (c) 2011 Ryan Day
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/mit-license.php
*
* EXPORTS:
* {
* QRCode:QRCode
* QRErrorCorrectLevel:QRErrorCorrectLevel
* }
//---------------------------------------------------------------------
// QRCode for JavaScript
//
// Copyright (c) 2009 Kazuhiko Arase
//
// URL: http://www.d-project.com/
//
// Licensed under the MIT license:
// http://www.opensource.org/licenses/mit-license.php
//
// The word "QR Code" is registered trademark of
// DENSO WAVE INCORPORATED
// http://www.denso-wave.com/qrcode/faqpatent-e.html
//
//---------------------------------------------------------------------
*/
module.exports = QRCode
/**
* Add finder patterns bits to matrix
*
* @param {BitMatrix} matrix Modules matrix
* @param {Number} version QR Code version
*/
function setupFinderPattern (matrix, version) {
var size = matrix.size
var pos = FinderPattern.getPositions(version)
for (var i = 0; i < pos.length; i++) {
var row = pos[i][0]
var col = pos[i][1]
for (var r = -1; r <= 7; r++) {
if (row + r <= -1 || size <= row + r) continue
for (var c = -1; c <= 7; c++) {
if (col + c <= -1 || size <= col + c) continue
if ((r >= 0 && r <= 6 && (c === 0 || c === 6)) ||
(c >= 0 && c <= 6 && (r === 0 || r === 6)) ||
(r >= 2 && r <= 4 && c >= 2 && c <= 4)) {
matrix.set(row + r, col + c, true, true)
} else {
matrix.set(row + r, col + c, false, true)
}
}
}
}
}
/**
* Add timing pattern bits to matrix
*
* Note: this function must be called before {@link setupAlignmentPattern}
*
* @param {BitMatrix} matrix Modules matrix
*/
function setupTimingPattern (matrix) {
var size = matrix.size
for (var r = 8; r < size - 8; r++) {
var value = r % 2 === 0
matrix.set(r, 6, value, true)
matrix.set(6, r, value, true)
}
}
/**
* Add alignment patterns bits to matrix
*
* Note: this function must be called after {@link setupTimingPattern}
*
* @param {BitMatrix} matrix Modules matrix
* @param {Number} version QR Code version
*/
function setupAlignmentPattern (matrix, version) {
var pos = AlignmentPattern.getPositions(version)
for (var i = 0; i < pos.length; i++) {
var row = pos[i][0]
var col = pos[i][1]
for (var r = -2; r <= 2; r++) {
for (var c = -2; c <= 2; c++) {
if (r === -2 || r === 2 || c === -2 || c === 2 ||
(r === 0 && c === 0)) {
matrix.set(row + r, col + c, true, true)
} else {
matrix.set(row + r, col + c, false, true)
}
}
}
}
}
/**
* Add version info bits to matrix
*
* @param {BitMatrix} matrix Modules matrix
* @param {Number} version QR Code version
* @param {Boolean} reserve If true, marks bits as reserved and set their values to 0
*/
function setupVersionInfo (matrix, version, reserve) {
var size = matrix.size
var bits = Version.getEncodedBits(version)
var row, col, mod
for (var i = 0; i < 18; i++) {
row = Math.floor(i / 3)
col = i % 3 + size - 8 - 3
mod = (!reserve && ((bits >> i) & 1) === 1)
matrix.set(row, col, mod, true)
matrix.set(col, row, mod, true)
}
}
/**
* Add format info bits to matrix
*
* @param {BitMatrix} matrix Modules matrix
* @param {Number} errorCorrectionLevel Error correction level
* @param {Number} maskPattern Mask pattern reference value
* @param {Boolean} reserve If true, marks bits as reserved and set their values to 0
*/
function setupFormatInfo (matrix, errorCorrectionLevel, maskPattern, reserve) {
var size = matrix.size
var bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern)
var i, mod
for (i = 0; i < 15; i++) {
mod = (!reserve && ((bits >> i) & 1) === 1)
// vertical
if (i < 6) {
matrix.set(i, 8, mod, true)
} else if (i < 8) {
matrix.set(i + 1, 8, mod, true)
} else {
matrix.set(size - 15 + i, 8, mod, true)
}
// horizontal
if (i < 8) {
matrix.set(8, size - i - 1, mod, true)
} else if (i < 9) {
matrix.set(8, 15 - i - 1 + 1, mod, true)
} else {
matrix.set(8, 15 - i - 1, mod, true)
}
}
// fixed module
matrix.set(size - 8, 8, !reserve, true)
}
/**
* Add encoded data bits to matrix
*
* @param {BitMatrix} matrix Modules matrix
* @param {Buffer} data Data codewords
*/
function setupData (matrix, data) {
var size = matrix.size
var inc = -1
var row = size - 1
var bitIndex = 7
var byteIndex = 0
for (var col = size - 1; col > 0; col -= 2) {
if (col === 6) col--
while (true) {
for (var c = 0; c < 2; c++) {
if (!matrix.isReserved(row, col - c)) {
var dark = false
if (byteIndex < data.length) {
dark = (((data[byteIndex] >>> bitIndex) & 1) === 1)
}
matrix.set(row, col - c, dark)
bitIndex--
if (bitIndex === -1) {
byteIndex++
bitIndex = 7
}
}
}
row += inc
if (row < 0 || size <= row) {
row -= inc
inc = -inc
break
}
}
}
}
/**
* Create encoded codewords from data input
*
* @param {Number} version QR Code version
* @param {Number} errorCorrectionLevel Error correction level
* @param {ByteData} data Data input
* @return {Buffer} Buffer containing encoded codewords
*/
function createData (version, errorCorrectionLevel, data) {
// Prepare data buffer
var buffer = new BitBuffer()
// prefix data with mode indicator (4 bits in byte mode)
buffer.put(data.mode, 4)
// Prefix data with character count indicator.
// The character count indicator is a string of bits that represents the number of characters
// that are being encoded. The character count indicator must be placed after the mode indicator
// and must be a certain number of bits long, depending on the QR version and data mode
// @see {@link ByteData.getCharCountIndicator}.
buffer.put(data.getLength(), data.getCharCountIndicator(version))
// add binary data sequence to buffer
data.write(buffer)
// Calculate required number of bits
var totalCodewords = Utils.getSymbolTotalCodewords(version)
var ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)
var dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8
// Add a terminator.
// If the bit string is shorter than the total number of required bits,
// a terminator of up to four 0s must be added to the right side of the string.
// If the bit string is more than four bits shorter than the required number of bits,
// add four 0s to the end.
if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
buffer.put(0, 4)
}
// If the bit string is fewer than four bits shorter, add only the number of 0s that
// are needed to reach the required number of bits.
// After adding the terminator, if the number of bits in the string is not a multiple of 8,
// pad the string on the right with 0s to make the string's length a multiple of 8.
while (buffer.getLengthInBits() % 8 !== 0) {
buffer.putBit(0)
}
// Add pad bytes if the string is still shorter than the total number of required bits.
// Extend the buffer to fill the data capacity of the symbol corresponding to
// the Version and Error Correction Level by adding the Pad Codewords 11101100 (0xEC)
// and 00010001 (0x11) alternately.
var remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8
for (var i = 0; i < remainingByte; i++) {
buffer.put(i % 2 ? 0x11 : 0xEC, 8)
}
return createCodewords(buffer, version, errorCorrectionLevel)
}
/**
* Encode input data with Reed-Solomon and return codewords with
* relative error correction bits
*
* @param {BitBuffer} bitBuffer Data to encode
* @param {Number} version QR Code version
* @param {Number} errorCorrectionLevel Error correction level
* @return {Buffer} Buffer containing encoded codewords
*/
function createCodewords (bitBuffer, version, errorCorrectionLevel) {
// Total codewords for this QR code version (Data + Error correction)
var totalCodewords = Utils.getSymbolTotalCodewords(version)
// Total number of error correction codewords
var ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)
// Total number of data codewords
var dataTotalCodewords = totalCodewords - ecTotalCodewords
// Total number of blocks
var ecTotalBlocks = ECCode.getBlocksCount(version, errorCorrectionLevel)
// Calculate how many blocks each group should contain
var blocksInGroup2 = totalCodewords % ecTotalBlocks
var blocksInGroup1 = ecTotalBlocks - blocksInGroup2
var totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks)
var dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks)
var dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1
// Number of EC codewords is the same for both groups
var ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1
// Initialize a Reed-Solomon encoder with a generator polynomial of degree ecCount
var rs = new ReedSolomonEncoder(ecCount)
var offset = 0
var dcData = new Array(ecTotalBlocks)
var ecData = new Array(ecTotalBlocks)
var maxDataSize = 0
var buffer = new Buffer(bitBuffer.buffer)
// Divide the buffer into the required number of blocks
for (var b = 0; b < ecTotalBlocks; b++) {
var dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2
// extract a block of data from buffer
dcData[b] = buffer.slice(offset, offset + dataSize)
// Calculate EC codewords for this data block
ecData[b] = rs.encode(dcData[b])
offset += dataSize
maxDataSize = Math.max(maxDataSize, dataSize)
}
// Create final data
// Interleave the data and error correction codewords from each block
var data = new Buffer(totalCodewords)
var index = 0
var i, r
// Add data codewords
for (i = 0; i < maxDataSize; i++) {
for (r = 0; r < ecTotalBlocks; r++) {
if (i < dcData[r].length) {
data[index++] = dcData[r][i]
}
}
}
// Apped EC codewords
for (i = 0; i < ecCount; i++) {
for (r = 0; r < ecTotalBlocks; r++) {
if (i < ecData[r].length) {
data[index++] = ecData[r][i]
}
}
}
return data
}
/**
* QR Code
*
* @param {Number} version QR Code version
* @param {Number} errorCorrectionLevel Error correction level
*/
function QRCode (version, errorCorrectionLevel) {
this.version = version
this.errorCorrectionLevel = errorCorrectionLevel
this.modules = null
this.moduleCount = 0
this.dataCache = null
this.data = null
}
/**
* Add datas to store
*
* @param {String, Number, Array, Buffer} data
*/
QRCode.prototype.addData = function addData (data) {
if (this.data) this.data.append(data)
else this.data = new ByteData(data)
this.dataCache = null
}
/**
* Return value of module at position
*
* @param {Number} row Row
* @param {Number} col Column
* @return {Boolean} Module value (black/white)
*/
QRCode.prototype.isDark = function isDark (row, col) {
if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {
throw new Error(row + ',' + col)
}
return this.modules.get(row, col)
}
/**
* Return QR Code size (number of modules in row/col)
*
* @return {Number} size
*/
QRCode.prototype.getModuleCount = function getModuleCount () {
return this.moduleCount
}
/**
* Build QR Code symbol
*/
QRCode.prototype.make = function make () {
if (this.dataCache === null) {
// Use higher error correction level as default
if (typeof this.errorCorrectionLevel === 'undefined') this.errorCorrectionLevel = ECLevel.H
// Get the min version that can contain data
var bestVersion = Version.getBestVersionForData(this.data, this.errorCorrectionLevel)
// If no version is found, data cannot be stored
if (!bestVersion) {
throw new Error('The amount of data is too big to be stored in a QR Code')
}
// If not specified, use min version as default
if (!this.version) {
this.version = bestVersion
// Check if the specified version can contain the data
} else if (this.version < bestVersion) {
throw new Error('\n' +
'The chosen QR Code version cannot contain this amount of data.\n' +
'Max characters allowed with current config: ' +
Version.getCapacity(this.version, this.errorCorrectionLevel) + '\n' +
'Minimum version required to store current data: ' + bestVersion + '\n'
)
}
this.dataCache = createData(this.version, this.errorCorrectionLevel, this.data)
}
// Allocate matrix buffer
this.moduleCount = Utils.getSymbolSize(this.version)
this.modules = new BitMatrix(this.moduleCount)
// Add function modules
setupFinderPattern(this.modules, this.version)
setupTimingPattern(this.modules)
setupAlignmentPattern(this.modules, this.version)
// Add temporary blank bits for format info and version info just to set them as reserved.
// This is needed to prevent these bits from being masked by {@link MaskPattern.applyMask}
// since the masking operation must be performed only on the encoding region.
// These blocks will be replaced with correct values later in code.
setupFormatInfo(this.modules, this.errorCorrectionLevel, 0, true)
if (this.version >= 7) {
setupVersionInfo(this.modules, this.version, true)
}
// Add data codewords
setupData(this.modules, this.dataCache)
// Find best mask pattern
var maskPattern = MaskPattern.getBestMask(this.modules)
// Apply mask pattern
MaskPattern.applyMask(maskPattern, this.modules)
// Replace format info bits with correct values
setupFormatInfo(this.modules, this.errorCorrectionLevel, maskPattern)
// Replace version info bits with correct values
if (this.version >= 7) {
setupVersionInfo(this.modules, this.version)
}
}

59
lib/core/reed-solomon-encoder.js Normal file
View file

@ -0,0 +1,59 @@
var Buffer = require('../utils/buffer')
var Polynomial = require('./polynomial')
function ReedSolomonEncoder (degree) {
this.genPoly = undefined
this.degree = degree
if (this.degree) this.initialize(this.degree)
}
/**
* Initialize the encoder.
* The input param should correspond to the number of error correction codewords.
*
* @param {Number} degree
*/
ReedSolomonEncoder.prototype.initialize = function initialize (degree) {
// create an irreducible generator polynomial
this.degree = degree
this.genPoly = Polynomial.generateECPolynomial(this.degree)
}
/**
* Encodes a chunk of data
*
* @param {Buffer} data Buffer containing input data
* @return {Buffer} Buffer containing encoded data
*/
ReedSolomonEncoder.prototype.encode = function encode (data) {
if (!this.genPoly) {
throw new Error('Encoder not initialized')
}
// Calculate EC for this data block
// extends data size to data+genPoly size
var pad = new Buffer(this.degree)
pad.fill(0)
var paddedData = Buffer.concat([data, pad], data.length + this.degree)
// The error correction codewords are the remainder after dividing the data codewords
// by a generator polynomial
var remainder = Polynomial.mod(paddedData, this.genPoly)
// return EC data blocks (last n byte, where n is the degree of genPoly)
// If coefficients number in remainder are less than genPoly degree,
// pad with 0s to the left to reach the needed number of coefficients
var start = this.degree - remainder.length
if (start > 0) {
var buff = new Buffer(this.degree)
buff.fill(0)
remainder.copy(buff, start)
return buff
}
return remainder
}
module.exports = ReedSolomonEncoder

46
lib/core/utils.js Normal file
View file

@ -0,0 +1,46 @@
var CODEWORDS_COUNT = [
0, // Not used
26, 44, 70, 100, 134, 172, 196, 242, 292, 346,
404, 466, 532, 581, 655, 733, 815, 901, 991, 1085,
1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185,
2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706
]
/**
* Returns the QR Code size for the specified version
*
* @param {Number} version QR Code version
* @return {Number} size of QR code
*/
exports.getSymbolSize = function getSymbolSize (version) {
if (!version) throw new Error('"version" cannot be null or undefined')
if (version < 1 || version > 40) throw new Error('"version" should be in range from 1 to 40')
return version * 4 + 17
}
/**
* Returns the total number of codewords used to store data and EC information.
*
* @param {Number} version QR Code version
* @return {Number} Data length in bits
*/
exports.getSymbolTotalCodewords = function getSymbolTotalCodewords (version) {
return CODEWORDS_COUNT[version]
}
/**
* Encode data with Bose-Chaudhuri-Hocquenghem
*
* @param {Number} data Value to encode
* @return {Number} Encoded value
*/
exports.getBCHDigit = function (data) {
var digit = 0
while (data !== 0) {
digit++
data >>>= 1
}
return digit
}

101
lib/core/version.js Executable file
View file

@ -0,0 +1,101 @@
var Buffer = require('../utils/buffer')
var Utils = require('./utils')
var ECCode = require('./error-correction-code')
var ECLevel = require('./error-correction-level')
var ByteData = require('./byte-data')
// Generator polynomial used to encode version information
var G18 = (1 << 12) | (1 << 11) | (1 << 10) | (1 << 9) | (1 << 8) | (1 << 5) | (1 << 2) | (1 << 0)
var G18_BCH = Utils.getBCHDigit(G18)
var getBestVersionForDataLength = function getBestVersionForDataLength (length, errorCorrectionLevel) {
for (var currentVersion = 1; currentVersion <= 40; currentVersion++) {
if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel)) return currentVersion
}
return undefined
}
/**
* Check if QR Code version is valid
*
* @param {Number} version QR Code version
* @return {Boolean} true if valid version, false otherwise
*/
exports.isValidVersion = function isValidVersion (version) {
return !isNaN(version) && version >= 1 && version <= 40
}
/**
* Returns how much data can be stored with the specified QR code version
* and error correction level
*
* @param {Number} version QR Code version (1-40)
* @param {Number} errorCorrectionLevel Error correction level
* @return {Number} Quantity of storable data
*/
exports.getCapacity = function getCapacity (version, errorCorrectionLevel) {
if (!exports.isValidVersion(version)) {
throw new Error('Invalid QR Code version')
}
// Total codewords for this QR code version (Data + Error correction)
var totalCodewords = Utils.getSymbolTotalCodewords(version)
// Total number of error correction codewords
var ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)
// Total number of data codewords
var dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8
// Character count indicator + mode indicator bits
var reservedBits = ByteData.getCharCountIndicator(version) + 4
// Return max number of storable codewords
return Math.floor((dataTotalCodewordsBits - reservedBits) / 8)
}
/**
* Returns the minimum version needed to contain the amount of data
*
* @param {Buffer, Array, ByteData} data Data buffer
* @param {Number} [errorCorrectionLevel=H] Error correction level
* @return {Number} QR Code version
*/
exports.getBestVersionForData = function getBestVersionForData (data, errorCorrectionLevel) {
var dataLength
if (data instanceof ByteData) dataLength = data.getLength()
else if (Buffer.isBuffer(data)) dataLength = data.length
else dataLength = new Buffer(data).length
var ecl = errorCorrectionLevel
if (typeof ecl === 'undefined') ecl = ECLevel.H
return getBestVersionForDataLength(dataLength, ecl)
}
/**
* Returns version information with relative error correction bits
*
* The version information is included in QR Code symbols of version 7 or larger.
* It consists of an 18-bit sequence containing 6 data bits,
* with 12 error correction bits calculated using the (18, 6) Golay code.
*
* @param {Number} version QR Code version
* @return {Number} Encoded version info bits
*/
exports.getEncodedBits = function getEncodedBits (version) {
if (!exports.isValidVersion(version) || version < 7) {
throw new Error('Invalid QR Code version')
}
var d = version << 12
while (Utils.getBCHDigit(d) - G18_BCH >= 0) {
d ^= (G18 << (Utils.getBCHDigit(d) - G18_BCH))
}
return (version << 12) | d
}

239
lib/index.js Normal file
View file

@ -0,0 +1,239 @@
/*
*copyright Ryan Day 2012
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/mit-license.php
*
* this is the main server side application file for node-qrcode.
* these exports use serverside canvas api methods for file IO and buffers
*
*/
var QRCodeLib = require('./renderer/qrcode-draw')
var terminalRender = require('./renderer/terminal')
var svgRender = require('./renderer/svg')
var Canvas = require('canvas')
var fs = require('fs')
var QRCodeDraw = QRCodeLib.QRCodeDraw
// EXPORTS
//
// breaking change to 0.1 this used to be an instance. now it returns the constructor.
//
exports.QRCodeDraw = QRCodeDraw
//
// export error correct levels.
//
exports.errorCorrectLevels = QRCodeLib.QRErrorCorrectLevel
//
// export original canvas to be used with draw method, esp. Canvas.Image
//
exports.canvas = Canvas
/*
* provide an api to return the max characters allowed for given dimensions, and miniumum error correction level
* the qr code library will always use the maximum error correction level for the given numbar of chars constrained by size
*/
exports.getMaxChars = function (minErrorCorrectionLevel, width, moduleScale) {
// TODO THIS NEEDS TO WORK
console.log('this doesnt work yet. comming soon =)')
}
var parseOptions = function (options) {
var textKeys = {
'minimum': QRCodeLib.QRErrorCorrectLevel.L,
'medium': QRCodeLib.QRErrorCorrectLevel.M,
'high': QRCodeLib.QRErrorCorrectLevel.Q,
'max': QRCodeLib.QRErrorCorrectLevel.H
}
if (options.errorCorrectLevel) {
var ec = options.errorCorrectLevel
if (textKeys[ec]) {
options.errorCorrectLevel = textKeys[ec]
}
}
return options
}
// returns Canvas Object with qr code drawn on it
/*
* String text, optional Object options, Function callback
*/
var draw = exports.draw = function (text, options, cb) {
var args = Array.prototype.slice.call(arguments)
cb = args.pop()
if (typeof cb !== 'function') {
throw new TypeError('last argument must be a function')
}
text = args.shift()
options = args.shift() || {}
options = parseOptions(options)
// NOTE the width and height are determined from within the qr code lib and are not configurable from the outside yet
var drawInstance = new QRCodeDraw()
drawInstance.draw(new Canvas(200, 200), text, options, function (error, canvas, qrWidth) {
cb(error, canvas, qrWidth)
})
}
// returns data uri for drawn qrcode png
exports.toDataURL = exports.toDataURI = function (text, options, cb) {
if (typeof options === 'function') {
cb = options
options = {}
}
draw(text, options, function (error, canvas) {
if (error) {
cb(error)
} else {
canvas.toDataURL(cb)
}
})
}
// synchronous PNGStream
exports.toPNGStream = function (text, WSpath, options, cb) {
if (typeof options === 'function') {
cb = options
options = {}
}
var out = fs.createWriteStream(WSpath)
draw(text, options, function (error, canvas) {
var stream
if (error) {
cb(error, '')
} else {
stream = canvas.createPNGStream()
}
stream.pipe(out)
stream.on('end', function () {
cb(error, '')
})
stream.pipe(out)
})
return out
}
// returns bytes written to file
exports.save = function (path, text, options, cb) {
if (typeof options === 'function') {
cb = options
options = {}
}
var fileExt = path.slice((path.lastIndexOf('.') - 1 >>> 0) + 2).toLowerCase()
if (fileExt === 'svg') {
saveSvg(path, text, options, cb)
} else {
savePng(path, text, options, cb)
}
}
function savePng (path, text, options, cb) {
draw(text, options, function (error, canvas) {
if (error) {
throw new Error(error)
}
var fd
var buf
var fdAndBuf = function () {
fs.write(fd, buf, 0, buf.length, 0, function (fsErr, written) {
fs.close(fd)
if (cb) cb(fsErr, written)
})
}
// run non dependent async calls at the same time ish
canvas.toBuffer(function (canvasErr, _buf) {
if (canvasErr) return cb(canvasErr)
buf = _buf
if (fd) fdAndBuf()
})
fs.open(path, 'w', function (fsErr, _fd) {
if (fsErr) return cb(fsErr)
fd = _fd
if (buf) fdAndBuf()
})
})
}
function saveSvg (path, text, options, cb) {
exports.drawSvg(text, function (error, code) {
if (!error) {
fs.writeFile(path, code, function (fsErr) {
return cb(fsErr, fsErr ? null : code)
})
}
})
}
//
// this returns an array of points that have either a 0 or 1 value representing 0 for light and 1 for dark
// these values include points in the white edge of the qrcode because that edge is actually part of the spec
//
exports.drawBitArray = function (text, options, cb) {
if (typeof options === 'function') {
cb = options
options = {}
}
options = parseOptions(options)
var drawInstance = new QRCodeDraw()
drawInstance.drawBitArray(text, options, function (error, bits, width) {
cb(error, bits, width)
})
}
//
// draw qr in your terminal!
//
exports.drawText = function (text, options, cb) {
if (typeof options === 'function') {
cb = options
options = {}
}
var drawInstance = new QRCodeDraw()
drawInstance.drawBitArray(text, function (error, bits, width) {
if (!error) {
var code = terminalRender.renderBits(bits, width)
cb(error, code)
} else {
cb(error, null)
}
})
}
exports.drawSvg = function (text, options, cb) {
if (typeof options === 'function') {
cb = options
options = {}
}
var drawInstance = new QRCodeDraw()
drawInstance.drawBitArray(text, function (error, bits, width) {
if (!error) {
var code = svgRender.renderBits(bits, width, options)
cb(error, code)
} else {
cb(error, null)
}
})
}

51
lib/qrcapacitytable.js
View file

@ -1,51 +0,0 @@
/**
this contains the max string length for all qr code Versions in Binary Safe / Byte Mode
each entry is in the order of error correct level
[L,M,Q,H]
the qrcode lib sets strange values for QRErrorCorrectLevel having to do with masking against patterns
the maximum string length for error correct level H is 1273 characters long.
*/
exports.QRCapacityTable = [
[17,14,11,7]
,[32,26,20,14]
,[53,42,32,24]
,[78,62,46,34]
,[106,84,60,44]
,[134,106,74,58]
,[154,122,86,64]
,[192,152,108,84]
,[230,180,130,98]
,[271,213,151,119]
,[321,251,177,137]//11
,[367,287,203,155]
,[425,331,241,177]
,[458,362,258,194]
,[520,412,292,220]
,[586,450,322,250]
,[644,504,364,280]
,[718,560,394,310]
,[792,624,442,338]
,[858,666,482,382]
,[929,711,509,403]
,[1003,779,565,439]
,[1091,857,611,461]
,[1171,911,661,511]//24
,[1273,997,715,535]
,[1367,1059,751,593]
,[1465,1125,805,625]
,[1528,1190,868,658]//28
,[1628,1264,908,698]
,[1732,1370,982,742]
,[1840,1452,1030,790]
,[1952,1538,1112,842]//32
,[2068,1628,1168,898]
,[2188,1722,1228,958]
,[2303,1809,1283,983]
,[2431,1911,1351,1051]//36
,[2563,1989,1423,1093]
,[2699,2099,1499,1139]
,[2809,2213,1579,1219]
,[2953,2331,1663,1273]//40
];

266
lib/qrcode-draw.js
View file

@ -1,266 +0,0 @@
/*
* copyright 2010-2012 Ryan Day
* http://github.com/soldair/node-qrcode
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/mit-license.php
*
* canvas example and fallback support example provided by Joshua Koo
* http://jabtunes.com/labs/qrcode.html
* "Instant QRCode Mashup by Joshua Koo!"
* as far as i can tell the page and the code on the page are public domain
*
* original table example and library provided by Kazuhiko Arase
* http://d-project.googlecode.com/svn/trunk/misc/qrcode/js/
*
*/
var bops = require('bops')
var QRCodeLib = require('./qrcode.js');
var QRVersionCapacityTable = require('./qrcapacitytable.js').QRCapacityTable;
var QRCode = QRCodeLib.QRCode;
exports.QRCodeDraw = QRCodeDraw;
exports.QRVersionCapacityTable = QRVersionCapacityTable;
exports.QRErrorCorrectLevel = QRCodeLib.QRErrorCorrectLevel;
exports.QRCode = QRCodeLib.QRCode;
function QRCodeDraw(){}
QRCodeDraw.prototype = {
scale:4,//4 px module size
defaultMargin:20,
marginScaleFactor:5,
// you may configure the error behavior for input string too long
errorBehavior:{
length:'trim'
},
color:{
dark:'black',
light:'white'
},
defaultErrorCorrectLevel:QRCodeLib.QRErrorCorrectLevel.H,
QRErrorCorrectLevel:QRCodeLib.QRErrorCorrectLevel,
draw:function(canvas,text,options,cb){
var level,
error,
errorCorrectLevel;
var args = Array.prototype.slice.call(arguments);
cb = args.pop();
canvas = args.shift();
text = args.shift();
options = args.shift()||{};
if(typeof cb != 'function') {
//enforce callback api just in case the processing can be made async in the future
// or support proc open to libqrencode
throw new Error('callback required');
}
if(typeof options !== "object"){
options.errorCorrectLevel = options;
}
this.QRVersion(
text
,options.errorCorrectLevel||this.QRErrorCorrectLevel.H
,options.version
,function(e,t,l,ec){
text = t,level = l,error = e,errorCorrectLevel = ec;
});
this.scale = options.scale||this.scale;
this.margin = typeof(options.margin) === 'undefined' ? this.defaultMargin : options.margin;
if(!level) {
//if we are unable to find an appropriate qr level error out
cb(error,canvas);
return;
}
//create qrcode!
try{
var qr = new QRCodeLib.QRCode(level, errorCorrectLevel)
, scale = this.scale||4
, ctx = canvas.getContext('2d')
, width = 0;
qr.addData(text);
qr.make();
var margin = this.marginWidth();
var currenty = margin;
width = this.dataWidth(qr)+ margin*2;
this.resetCanvas(canvas,ctx,width);
for (var r = 0,rl=qr.getModuleCount(); r < rl; r++) {
var currentx = margin;
for (var c = 0,cl=qr.getModuleCount(); c < cl; c++) {
if (qr.isDark(r, c) ) {
ctx.fillStyle = this.color.dark;
ctx.fillRect (currentx, currenty, scale, scale);
} else if(this.color.light){
//if falsy configured color
ctx.fillStyle = this.color.light;
ctx.fillRect (currentx, currenty, scale, scale);
}
currentx += scale;
}
currenty += scale;
}
} catch (e) {
error = e;
}
cb(error,canvas,width);
},
drawBitArray:function(text/*,errorCorrectLevel,options,cb*/) {
var args = Array.prototype.slice.call(arguments),
cb = args.pop(),
text = args.shift(),
options = args.shift() || {};
//argument processing
if(typeof cb != 'function') {
//enforce callback api just in case the processing can be made async in the future
// or support proc open to libqrencode
throw new Error('callback required as last argument');
}
//this interface kinda sucks - there is very small likelyhood of this ever being async
this.QRVersion(text,options.errorCorrectLevel,options.version,function(e,t,l,ec){
text = t,level = l,error = e,errorCorrectLevel = ec;
});
if(!level) {
//if we are unable to find an appropriate qr level error out
cb(error,[],0);
return;
}
//create qrcode!
try{
var qr = new QRCodeLib.QRCode(level, errorCorrectLevel)
, scale = this.scale||4
, width = 0,bits,bitc=0,currenty=0;
qr.addData(text);
qr.make();
width = this.dataWidth(qr,1);
bits = new Array(width*width);
for (var r = 0,rl=qr.getModuleCount(); r < rl; r++) {
for (var c = 0,cl=qr.getModuleCount(); c < cl; c++) {
if (qr.isDark(r, c) ) {
bits[bitc] = 1;
} else {
bits[bitc] = 0;
}
bitc++;
}
}
} catch (e) {
error = e;
console.log(e.stack);
}
cb(error,bits,width);
},
QRVersion:function(text,errorCorrectLevel,version,cb){
var c = bops.from(text).length,// BINARY LENGTH!
error,
errorCorrectLevel = this.QRErrorCorrectLevel[errorCorrectLevel];
if(errorCorrectLevel === undefined) errorCorrectLevel = this.defaultErrorCorrectLevel
var errorCorrectIndex = [1,0,3,2],//fix odd mapping to order in table
keys = ['L','M','Q','H'],
capacity = 0,
versionSpecified = false;
if(typeof version !== "undefined" && version !== null) {
versionSpecified = true;
}
//TODO ADD THROW FOR INVALID errorCorrectLevel...?
if(versionSpecified){
//console.log('SPECIFIED VERSION! ',version);
//i have specified a version. this will give me a fixed size qr code. version must be valid. 1-40
capacity = QRVersionCapacityTable[version][errorCorrectIndex[errorCorrectLevel]];
} else {
//figure out what version can hold the amount of text
for(var i=0,j=QRVersionCapacityTable.length;i<j;i++) {
capacity = QRVersionCapacityTable[i][errorCorrectIndex[errorCorrectLevel]];
if(c < QRVersionCapacityTable[i][errorCorrectIndex[errorCorrectLevel]]){
version = i+1;
break;
}
}
//if not version set to max
if(!version) {
version = QRVersionCapacityTable.length-1;
}
}
if(capacity < c){
if(this.errorBehavior.length == 'trim'){
text = text.substr(0,capacity);
level = QRVersionCapacityTable.length;
} else {
error = new Error('input string too long for error correction '
+keys[errorCorrectIndex[errorCorrectLevel]]
+' max length '
+ capacity
+' for qrcode version '+version
);
}
}
if(cb) {
cb(error,text,version,errorCorrectLevel);
}
return version;
},
marginWidth:function(){
var margin = this.margin;
this.scale = this.scale||4;
//elegant white space next to code is required by spec
if ((this.scale * this.marginScaleFactor > margin) && margin > 0){
margin = this.scale * this.marginScaleFactor;
}
return margin;
},
dataWidth:function(qr,scale){
return qr.getModuleCount()*(scale||this.scale||4);
},
resetCanvas:function(canvas,ctx,width){
ctx.clearRect(0,0,canvas.width,canvas.height);
if(!canvas.style) canvas.style = {};
canvas.style.height = canvas.height = width;//square!
canvas.style.width = canvas.width = width;
if(this.color.light){
ctx.fillStyle = this.color.light;
ctx.fillRect(0,0,canvas.width,canvas.height);
} else {
//support transparent backgrounds?
//not exactly to spec but i really would like someone to be able to add a background with heavily reduced luminosity for simple branding
//i could just ditch this because you could also just set #******00 as the color =P
ctx.clearRect(0,0,canvas.width,canvas.height);
}
}
};

1167
lib/qrcode.js
View file

File diff suppressed because it is too large Load diff

173
lib/renderer/qrcode-draw.js Normal file
View file

@ -0,0 +1,173 @@
/*
* copyright 2010-2012 Ryan Day
* http://github.com/soldair/node-qrcode
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/mit-license.php
*
* canvas example and fallback support example provided by Joshua Koo
* http://jabtunes.com/labs/qrcode.html
* "Instant QRCode Mashup by Joshua Koo!"
* as far as i can tell the page and the code on the page are public domain
*
* original table example and library provided by Kazuhiko Arase
* http://d-project.googlecode.com/svn/trunk/misc/qrcode/js/
*
*/
var QRCodeLib = require('../core/qrcode')
var ErrorCorrectionLevel = require('../core/error-correction-level')
exports.QRCodeDraw = QRCodeDraw
exports.QRErrorCorrectLevel = ErrorCorrectionLevel
exports.QRCode = QRCodeLib
function QRCodeDraw () {}
QRCodeDraw.prototype = {
scale: 4, // 4 px module size
defaultMargin: 20,
marginScaleFactor: 5,
color: {
dark: 'black',
light: 'white'
},
QRErrorCorrectLevel: ErrorCorrectionLevel,
draw: function (canvas, text, options, cb) {
var error
var args = Array.prototype.slice.call(arguments)
cb = args.pop()
canvas = args.shift()
text = args.shift()
options = args.shift() || {}
if (typeof cb !== 'function') {
// enforce callback api just in case the processing can be made async in the future
// or support proc open to libqrencode
throw new Error('callback required')
}
if (typeof options !== 'object') {
options.errorCorrectLevel = options
}
this.scale = options.scale || this.scale
this.margin = typeof (options.margin) === 'undefined' ? this.defaultMargin : options.margin
// create qrcode!
try {
var qr = new QRCodeLib(options.version, options.errorCorrectLevel)
var scale = this.scale || 4
var ctx = canvas.getContext('2d')
var width = 0
qr.addData(text)
qr.make()
var margin = this.marginWidth()
var currenty = margin
width = this.dataWidth(qr) + margin * 2
this.resetCanvas(canvas, ctx, width)
for (var r = 0, rl = qr.getModuleCount(); r < rl; r++) {
var currentx = margin
for (var c = 0, cl = qr.getModuleCount(); c < cl; c++) {
if (qr.isDark(r, c)) {
ctx.fillStyle = this.color.dark
ctx.fillRect(currentx, currenty, scale, scale)
} else if (this.color.light) {
// if falsy configured color
ctx.fillStyle = this.color.light
ctx.fillRect(currentx, currenty, scale, scale)
}
currentx += scale
}
currenty += scale
}
} catch (e) {
error = e
}
cb(error, canvas, width)
},
drawBitArray: function (/* text, errorCorrectLevel,options,cb */) {
var args = Array.prototype.slice.call(arguments)
var cb = args.pop()
var text = args.shift()
var options = args.shift() || {}
var error
// argument processing
if (typeof cb !== 'function') {
// enforce callback api just in case the processing can be made async in the future
// or support proc open to libqrencode
throw new Error('callback required as last argument')
}
// create qrcode!
try {
var qr = new QRCodeLib(options.version, options.errorCorrectLevel)
var width = 0
var bits
var bitc = 0
qr.addData(text)
qr.make()
width = this.dataWidth(qr, 1)
bits = new Array(width * width)
for (var r = 0, rl = qr.getModuleCount(); r < rl; r++) {
for (var c = 0, cl = qr.getModuleCount(); c < cl; c++) {
if (qr.isDark(r, c)) {
bits[bitc] = 1
} else {
bits[bitc] = 0
}
bitc++
}
}
} catch (e) {
error = e
console.log(e.stack)
}
cb(error, bits, width)
},
marginWidth: function () {
var margin = this.margin
this.scale = this.scale || 4
// elegant white space next to code is required by spec
if ((this.scale * this.marginScaleFactor > margin) && margin > 0) {
margin = this.scale * this.marginScaleFactor
}
return margin
},
dataWidth: function (qr, scale) {
return qr.getModuleCount() * (scale || this.scale || 4)
},
resetCanvas: function (canvas, ctx, width) {
ctx.clearRect(0, 0, canvas.width, canvas.height)
if (!canvas.style) canvas.style = {}
canvas.style.height = canvas.height = width// square!
canvas.style.width = canvas.width = width
if (this.color.light) {
ctx.fillStyle = this.color.light
ctx.fillRect(0, 0, canvas.width, canvas.height)
} else {
// support transparent backgrounds?
// not exactly to spec but i really would like someone to be able to add a background with heavily reduced luminosity for simple branding
// i could just ditch this because you could also just set #******00 as the color =P
ctx.clearRect(0, 0, canvas.width, canvas.height)
}
}
}

44
lib/renderer/svg.js Normal file
View file

@ -0,0 +1,44 @@
exports.renderBits = function renderBits (bits, width, options) {
if (typeof bits === 'undefined' || !(bits instanceof Array)) {
throw new Error('"bits" must be a valid Array')
}
if (typeof bits === 'undefined' || isNaN(width)) {
throw new Error('"width" must be a valid number')
}
var dotsize = options.scale || 4
var margin = options.margin || 20
var qrcodesize = width * dotsize + margin * 2
var lightColor = options.lightColor || '#ffffff'
var darkColor = options.darkColor || '#000000'
var xmlStr = '<?xml version="1.0" encoding="utf-8"?>\n'
xmlStr += '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n'
xmlStr += '<svg version="1.1" baseProfile="full"'
xmlStr += ' width="' + qrcodesize + '" height="' + qrcodesize + '"'
xmlStr += ' viewBox="0 0 ' + qrcodesize + ' ' + qrcodesize + '"'
xmlStr += ' xmlns="http://www.w3.org/2000/svg"'
xmlStr += ' xmlns:xlink="http://www.w3.org/1999/xlink"'
xmlStr += ' xmlns:ev="http://www.w3.org/2001/xml-events">\n'
xmlStr += '<rect x="0" y="0" width="' + qrcodesize + '" height="' + qrcodesize + '" fill="' + lightColor + '" />\n'
xmlStr += '<defs><rect id="p" width="' + dotsize + '" height="' + dotsize + '" /></defs>\n'
xmlStr += '<g fill="' + darkColor + '">\n'
xmlStr = bits.reduce(function (xml, bit, index) {
if (!bit) return xml
var x = margin + (index % width) * dotsize
var y = margin + Math.floor(index / width) * dotsize
xml += '<use x="' + x + '" y="' + y + '" xlink:href="#p" />\n'
return xml
}, xmlStr)
xmlStr += '</g>\n'
xmlStr += '</svg>'
return xmlStr
}

61
lib/renderer/terminal.js Normal file
View file

@ -0,0 +1,61 @@
require('colors')
exports.renderBits = function renderBits (bits, width, inverse) {
var bottom = '▄'
var both = '█'
var top = '▀'
var bit = 0
var nextRow
var _b, _t
var out = ' '
// var _debug = []
// var row = 0
var i, j
// add one row to out for top framing
for (i = 0; i < width; ++i) {
out += ' '
}
out += ' \n'
for (i = 0; i < (width / 2); i++) {
// console.error('row ',i);
// _debug[row] = [];
// _debug[row+1] = [];
out += ' '
for (j = 0; j < width; j++) {
// console.log('column ',j);
nextRow = bit + width
var c = ' '
_t = 0
_b = 0
if (bits[bit]) {
_t = 1
c = '\u001b[53m' + top
}
if (bits[nextRow]) {
_b = 1
c = bottom.underline
}
if (_b && _t) {
c = '\u001b[53m' + (both.underline)
}
// _debug[row].push(_t+'');
// _debug[row+1].push(_b+'');
out += c
bit++
}
bit += width
// console.log('advancing bit to ',bit);
// row += 2
out += ' \n'
}
// defaults tp inverse. this makes sense for people with dark terminals.
return inverse ? out : out.inverse
}

44
lib/svgrender.js
View file

@ -1,44 +0,0 @@
module.exports.renderBits = renderBits;
function renderBits(bits,width,options) {
if (typeof bits === 'undefined' || !(bits instanceof Array)) {
throw new Error('"bits" must be a valid Array');
}
if (typeof bits === 'undefined' || isNaN(width)) {
throw new Error('"width" must be a valid number');
}
var dotsize = options.scale || 4;
var margin = options.margin || 20;
var qrcodesize = width * dotsize + margin * 2;
var lightColor = options.lightColor || '#ffffff';
var darkColor = options.darkColor || '#000000';
var xmlStr = '<?xml version="1.0" encoding="utf-8"?>\n';
xmlStr += '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n';
xmlStr += '<svg version="1.1" baseProfile="full"';
xmlStr += ' width="' + qrcodesize + '" height="' + qrcodesize + '"';
xmlStr += ' viewBox="0 0 '+ qrcodesize + ' ' + qrcodesize + '"';
xmlStr += ' xmlns="http://www.w3.org/2000/svg"';
xmlStr += ' xmlns:xlink="http://www.w3.org/1999/xlink"';
xmlStr += ' xmlns:ev="http://www.w3.org/2001/xml-events">\n';
xmlStr += '<rect x="0" y="0" width="' + qrcodesize + '" height="' + qrcodesize + '" fill="' + lightColor + '" />\n';
xmlStr += '<defs><rect id="p" width="'+ dotsize +'" height="'+ dotsize + '" /></defs>\n';
xmlStr += '<g fill="' + darkColor + '">\n';
xmlStr = bits.reduce(function (xml, bit, index) {
if (!bit) return xml;
var x = margin + (index % width) * dotsize;
var y = margin + Math.floor(index / width) * dotsize;
return xml += '<use x="' + x + '" y="' + y + '" xlink:href="#p" />\n'
}, xmlStr);
xmlStr += '</g>\n';
xmlStr += '</svg>';
return xmlStr
}

61
lib/termialrender.js
View file

@ -1,61 +0,0 @@
var colors = require('colors');
module.exports.renderBits = renderBits;
function renderBits(bits,width,inverse){
var bottom = '▄';
var both = '█';
var top = '▀';
var bit = 0,nextRow,_b,_t,out = ' ',_debug = [],row = 0,i,j;
//add one row to out for top framing
for(i=0;i<width;++i) {
out += " ";
}
out += " \n";
for(i = 0;i<(width/2);i++){
//console.error('row ',i);
//_debug[row] = [];
//_debug[row+1] = [];
out += " ";
for(j = 0;j<width;j++){
//console.log('column ',j);
nextRow = bit+width;
c = ' ';
_t = 0;
_b = 0;
if(bits[bit]) {
_t = 1;
c = '\033[53m'+top;
}
if(bits[nextRow]){
_b = 1;
c = bottom.underline;
}
if(_b && _t) {
c = '\033[53m'+(both.underline);
}
//_debug[row].push(_t+'');
//_debug[row+1].push(_b+'');
out += c;
bit++;
}
bit += width;
//console.log('advancing bit to ',bit);
row += 2;
out += " \n";
}
//defaults tp inverse. this makes sense for people with dark terminals.
return inverse?out:out.inverse;
}

1
lib/utils/buffer.js Normal file
View file

@ -0,0 +1 @@
module.exports = require('buffer').Buffer

3
lib/utils/is-array.js Normal file
View file

@ -0,0 +1,3 @@
module.exports = Array.isArray || function (arr) {
return {}.toString.call(arr) === '[object Array]'
}

458
lib/utils/typedarray-buffer.js Normal file
View file

@ -0,0 +1,458 @@
/**
* Implementation of a subset of node.js Buffer methods for the browser.
* Based on https://github.com/feross/buffer
*/
/* eslint-disable no-proto */
'use strict'
var isArray = require('./is-array')
var K_MAX_LENGTH = 0x7fffffff
function Buffer (arg, offset, length) {
if (typeof arg === 'number') {
return allocUnsafe(arg)
}
return from(arg, offset, length)
}
Buffer.prototype.__proto__ = Uint8Array.prototype
Buffer.__proto__ = Uint8Array
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
if (typeof Symbol !== 'undefined' && Symbol.species &&
Buffer[Symbol.species] === Buffer) {
Object.defineProperty(Buffer, Symbol.species, {
value: null,
configurable: true,
enumerable: false,
writable: false
})
}
function checked (length) {
// Note: cannot use `length < K_MAX_LENGTH` here because that fails when
// length is NaN (which is otherwise coerced to zero.)
if (length >= K_MAX_LENGTH) {
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
}
return length | 0
}
function isnan (val) {
return val !== val // eslint-disable-line no-self-compare
}
function createBuffer (length) {
var buf = new Uint8Array(length)
buf.__proto__ = Buffer.prototype
return buf
}
function allocUnsafe (size) {
return createBuffer(size < 0 ? 0 : checked(size) | 0)
}
function fromString (string) {
var length = byteLength(string) | 0
var buf = createBuffer(length)
var actual = buf.write(string)
if (actual !== length) {
// Writing a hex string, for example, that contains invalid characters will
// cause everything after the first invalid character to be ignored. (e.g.
// 'abxxcd' will be treated as 'ab')
buf = buf.slice(0, actual)
}
return buf
}
function fromArrayLike (array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0
var buf = createBuffer(length)
for (var i = 0; i < length; i += 1) {
buf[i] = array[i] & 255
}
return buf
}
function fromArrayBuffer (array, byteOffset, length) {
array.byteLength // this throws if `array` is not a valid ArrayBuffer
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('\'offset\' is out of bounds')
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('\'length\' is out of bounds')
}
var buf
if (byteOffset === undefined && length === undefined) {
buf = new Uint8Array(array)
} else if (length === undefined) {
buf = new Uint8Array(array, byteOffset)
} else {
buf = new Uint8Array(array, byteOffset, length)
}
// Return an augmented `Uint8Array` instance
buf.__proto__ = Buffer.prototype
return buf
}
function fromObject (obj) {
if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0
var buf = createBuffer(len)
if (buf.length === 0) {
return buf
}
obj.copy(buf, 0, 0, len)
return buf
}
if (obj) {
if ((typeof ArrayBuffer !== 'undefined' &&
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
if (typeof obj.length !== 'number' || isnan(obj.length)) {
return createBuffer(0)
}
return fromArrayLike(obj)
}
if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
return fromArrayLike(obj.data)
}
}
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
}
function utf8ToBytes (string, units) {
units = units || Infinity
var codePoint
var length = string.length
var leadSurrogate = null
var bytes = []
for (var i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i)
// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (!leadSurrogate) {
// no lead yet
if (codePoint > 0xDBFF) {
// unexpected trail
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
}
// valid lead
leadSurrogate = codePoint
continue
}
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
}
// valid surrogate pair
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
}
leadSurrogate = null
// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x110000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}
return bytes
}
function byteLength (string) {
if (Buffer.isBuffer(string)) {
return string.length
}
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
return string.byteLength
}
if (typeof string !== 'string') {
string = '' + string
}
var len = string.length
if (len === 0) return 0
return utf8ToBytes(string).length
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; ++i) {
if ((i + offset >= dst.length) || (i >= src.length)) break
dst[i + offset] = src[i]
}
return i
}
function utf8Write (buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}
function from (value, offset, length) {
if (typeof value === 'number') {
throw new TypeError('"value" argument must not be a number')
}
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
return fromArrayBuffer(value, offset, length)
}
if (typeof value === 'string') {
return fromString(value, offset)
}
return fromObject(value)
}
Buffer.prototype.write = function write (string, offset, length) {
// Buffer#write(string)
if (offset === undefined) {
length = this.length
offset = 0
// Buffer#write(string, encoding)
} else if (length === undefined && typeof offset === 'string') {
length = this.length
offset = 0
// Buffer#write(string, offset[, length])
} else if (isFinite(offset)) {
offset = offset | 0
if (isFinite(length)) {
length = length | 0
} else {
length = undefined
}
}
var remaining = this.length - offset
if (length === undefined || length > remaining) length = remaining
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
throw new RangeError('Attempt to write outside buffer bounds')
}
return utf8Write(this, string, offset, length)
}
Buffer.prototype.slice = function slice (start, end) {
var len = this.length
start = ~~start
end = end === undefined ? len : ~~end
if (start < 0) {
start += len
if (start < 0) start = 0
} else if (start > len) {
start = len
}
if (end < 0) {
end += len
if (end < 0) end = 0
} else if (end > len) {
end = len
}
if (end < start) end = start
var newBuf = this.subarray(start, end)
// Return an augmented `Uint8Array` instance
newBuf.__proto__ = Buffer.prototype
return newBuf
}
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
if (!start) start = 0
if (!end && end !== 0) end = this.length
if (targetStart >= target.length) targetStart = target.length
if (!targetStart) targetStart = 0
if (end > 0 && end < start) end = start
// Copy 0 bytes; we're done
if (end === start) return 0
if (target.length === 0 || this.length === 0) return 0
// Fatal error conditions
if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
if (end < 0) throw new RangeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length) end = this.length
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start
}
var len = end - start
var i
if (this === target && start < targetStart && targetStart < end) {
// descending copy from end
for (i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start]
}
} else if (len < 1000) {
// ascending copy from start
for (i = 0; i < len; ++i) {
target[i + targetStart] = this[i + start]
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, start + len),
targetStart
)
}
return len
}
Buffer.prototype.fill = function fill (val, start, end) {
// Handle string cases:
if (typeof val === 'string') {
if (typeof start === 'string') {
start = 0
end = this.length
} else if (typeof end === 'string') {
end = this.length
}
if (val.length === 1) {
var code = val.charCodeAt(0)
if (code < 256) {
val = code
}
}
} else if (typeof val === 'number') {
val = val & 255
}
// Invalid ranges are not set to a default, so can range check early.
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError('Out of range index')
}
if (end <= start) {
return this
}
start = start >>> 0
end = end === undefined ? this.length : end >>> 0
if (!val) val = 0
var i
if (typeof val === 'number') {
for (i = start; i < end; ++i) {
this[i] = val
}
} else {
var bytes = Buffer.isBuffer(val)
? val
: new Buffer(val)
var len = bytes.length
for (i = 0; i < end - start; ++i) {
this[i + start] = bytes[i % len]
}
}
return this
}
Buffer.concat = function concat (list, length) {
if (!isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
if (list.length === 0) {
return createBuffer(null, 0)
}
var i
if (length === undefined) {
length = 0
for (i = 0; i < list.length; ++i) {
length += list[i].length
}
}
var buffer = allocUnsafe(length)
var pos = 0
for (i = 0; i < list.length; ++i) {
var buf = list[i]
if (!Buffer.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
buf.copy(buffer, pos)
pos += buf.length
}
return buffer
}
Buffer.byteLength = byteLength
Buffer.prototype._isBuffer = true
Buffer.isBuffer = function isBuffer (b) {
return !!(b != null && b._isBuffer)
}
module.exports = Buffer

37
package.json
View file

@ -11,35 +11,52 @@
"qrcode",
"barcode"
],
"main": "./qrcode.js",
"browser": "./lib/qrcode-draw.js",
"main": "./lib/index.js",
"browser": {
"./lib/index.js": "./lib/browser.js",
"./lib/utils/buffer.js": "./lib/utils/typedarray-buffer.js"
},
"files": [
"bin",
"build",
"lib"
],
"homepage": "http://github.com/soldair/node-qrcode",
"license": "MIT",
"scripts": {
"pretest": "node build.js",
"prepublish": "node build.js",
"test": "tap test/url.js test/svg.js"
"lint": "standard",
"pretest": "npm run lint",
"test": "node test.js",
"build": "node build.js",
"prepublish": "npm run build"
},
"bin": {
"qrcode": "./bin/qrcode"
},
"dependencies": {
"canvas": "~1.3.4",
"colors": "*",
"bops": "0.0.6"
"colors": "*"
},
"devDependencies": {
"browserify": "~2.29.0",
"browserify": "^13.1.1",
"canvasutil": "*",
"express": "2.5.x",
"libxmljs": "^0.18.0",
"standard": "*",
"tap": "*",
"uglify-js": "1.2.x"
"uglify-js": "^2.7.4"
},
"repository": {
"type": "git",
"url": "git://github.com/soldair/node-qrcode.git"
},
"engines": {
"node": ">= 0.6.0"
"node": ">= 0.10"
},
"standard": {
"ignore": [
"build/",
"examples/vendors/"
]
}
}

238
qrcode.js
View file

@ -1,238 +0,0 @@
/*
*copyright Ryan Day 2012
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/mit-license.php
*
* this is the main server side application file for node-qrcode.
* these exports use serverside canvas api methods for file IO and buffers
*
*/
var QRCodeLib = require('./lib/qrcode-draw')
, terminalRender = require('./lib/termialrender.js')
, svgRender = require('./lib/svgrender')
, Canvas = require('canvas')
, fs = require('fs');
var QRCodeDraw = QRCodeLib.QRCodeDraw,
QRCode = QRCodeLib.QRCode;
//EXPORTS
//
// breaking change to 0.1 this used to be an instance. now it returns the constructor.
//
exports.QRCodeDraw = QRCodeDraw;
//
// export error correct levels.
//
exports.errorCorrectLevels = QRCodeLib.QRErrorCorrectLevel;
//
// export original canvas to be used with draw method, esp. Canvas.Image
//
exports.canvas=Canvas;
/*
* provide an api to return the max characters allowed for given dimensions, and miniumum error correction level
* the qr code library will always use the maximum error correction level for the given numbar of chars constrained by size
*/
exports.getMaxChars = function(minErrorCorrectionLevel,width,moduleScale){
//TODO THIS NEEDS TO WORK
console.log('this doesnt work yet. comming soon =)');
};
var parseOptions = function(options) {
var textKeys = {'minimum':"L",'medium':"M",'high':"Q",'max':"H"}
if(options.errorCorrectLevel) {
var ec = options.errorCorrectLevel;
if(textKeys[ec]){
options.errorCorrectLevel = textKeys[ec];
}
}
return options;
};
// returns Canvas Object with qr code drawn on it
/*
* String text, optional Object options, Function callback
*/
var draw = exports.draw = function(text,options,cb){
var args = Array.prototype.slice.call(arguments);
cb = args.pop();
if(typeof cb != 'function') {
throw new TypeError('last argument must be a function');
}
text = args.shift();
options = args.shift()||{};
options=parseOptions(options);
//NOTE the width and height are determined from within the qr code lib and are not configurable from the outside yet
var drawInstance = new QRCodeDraw();
drawInstance.draw(new Canvas(200,200),text,options,function(error,canvas,qrWidth){
cb(error,canvas,qrWidth)
});
};
//returns data uri for drawn qrcode png
exports.toDataURL = exports.toDataURI = function(text,options,cb){
if(typeof options == 'function') {
cb = options;
options = {};
}
draw(text,options,function(error,canvas){
if(error) {
cb(error);
} else {
canvas.toDataURL(cb);
}
});
}
//synchronous PNGStream
exports.toPNGStream = function (text, WSpath, options,cb) {
if(typeof options == 'function'){
cb = options;
options = {};
}
var out = fs.createWriteStream(WSpath);
draw(text, options, function (error,canvas) {
if(error) {
cb(error,'');
} else {
stream = canvas.createPNGStream();
}
stream.pipe(out);
stream.on('end', function () {
cb(error,'');
});
stream.pipe(out);
});
return out;
}
//returns bytes written to file
exports.save = function(path,text,options,cb){
if(typeof options == 'function'){
cb = options;
options = {};
}
var fileExt = path.slice((path.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
if (fileExt === 'svg') {
saveSvg(path,text,options,cb);
} else {
savePng(path,text,options,cb);
}
};
function savePng(path,text,options,cb){
draw(text, options, function(error,canvas){
var fd,buf,fdAndBuf = function(){
fs.write(fd, buf, 0, buf.length, 0, function(fsErr, written){
fs.close(fd);
if(cb) cb(fsErr, written);
});
};
//run non dependent async calls at the same time ish
canvas.toBuffer(function(canvasErr, _buf){
if(canvasErr) return cb(canvasErr);
buf = _buf
if(fd) fdAndBuf();
});
fs.open(path, 'w', 0666, function(fsErr,_fd){
if(fsErr) return cb(fsErr);
fd = _fd
if(buf) fdAndBuf();
});
});
}
function saveSvg(path,text,options,cb){
exports.drawSvg(text,function(error,code){
if (!error) {
fs.writeFile(path, code, function(fsErr) {
return cb(fsErr, fsErr ? null : code);
});
}
});
}
//
//this returns an array of points that have either a 0 or 1 value representing 0 for light and 1 for dark
//these values include points in the white edge of the qrcode because that edge is actually part of the spec
//
exports.drawBitArray = function(text,options,cb){
if(typeof options == 'function'){
cb = options;
options = {};
}
options = parseOptions(options);
var drawInstance = new QRCodeDraw();
drawInstance.drawBitArray(text,options,function(error,bits,width){
cb(error,bits,width);
});
}
//
// draw qr in your terminal!
//
exports.drawText = function(text,options,cb){
if(typeof options == 'function'){
cb = options;
options = {};
}
var drawInstance = new QRCodeDraw();
drawInstance.drawBitArray(text,function(error,bits,width){
if (!error) {
var code = terminalRender.renderBits(bits,width);
cb(error,code);
} else {
cb(error,null);
}
});
}
exports.drawSvg = function(text,options,cb){
if(typeof options == 'function'){
cb = options;
options = {};
}
var drawInstance = new QRCodeDraw();
drawInstance.drawBitArray(text,function(error,bits,width){
if (!error) {
var code = svgRender.renderBits(bits,width,options);
cb(error,code);
} else {
cb(error,null);
}
});
}

8
qrcodeclient.js
View file

@ -1,8 +0,0 @@
var QRCodeLib = require('./lib/qrcode-draw.js');
if(typeof window !== "undefined") {
window.qrcodelib = window.QRCodeLib = QRCodeLib;
// monkey patch old api
QRCodeLib.qrcodedraw = QRCodeLib.QRCodeDraw;
}

16
test.js Normal file
View file

@ -0,0 +1,16 @@
var spawn = require('child_process').spawn
var opt = {
cwd: __dirname,
env: (function () {
process.env.NODE_PATH = './lib'
return process.env
}()),
stdio: [process.stdin, process.stdout, process.stderr]
}
spawn('node', [
'node_modules/.bin/tap',
'--cov',
'test/**/*.test.js'
], opt)

5
test/cli.js
View file

@ -1,5 +0,0 @@
var QRCode = require('../qrcode.js');
QRCode.drawText('yo yo yo',function(error,data){
console.log(data);
});

55
test/clientside.html
View file

@ -1,55 +0,0 @@
<!doctype html>
<html>
<head>
<title>client side test for node-qrcode</title>
<!--[if ie]><script type="text/javascript" src="vendors/excanvas/excanvas.js"></script><![endif]-->
<script src="/build/qrcode.js"></script>
<style>.b{display:block;}</style>
</head>
<body>
<canvas id="test"></canvas>
<label for="test-text" class="b">type here and watch it update!:</label>
<textarea id="test-text" class="b"></textarea>
<small style="color:#d4d4d4;" class="b">* i did not include jquery on purpose</small>
<script>
if(!window.console) window.console = {log:function(){},warn:function(){}};
var qrcodedraw = new qrcodelib.qrcodedraw();
//triggered errors will throw
qrcodedraw.errorBehavior.length = false;
var drawQR = function(text){
qrcodedraw.draw(document.getElementById('test'),text,function(error,canvas){
if(error) {
if(window.console && window.console.warn) {
console.warn(error);
} else {
alert(error);
}
}
});
}
var ta = document.getElementById('test-text'),last=0,lastTime = 1;
ta.addEventListener('keyup',function(){
var l = Date.now(),z = this;
last = l;
setTimeout(function(){
//this will kinda lock the browsers event loop for a sec.
//it could have some setTimeout within processing to make it more client side friendly. or web workers...
if(l == last) {
var s=Date.now();
drawQR(z.value);
lastTime = Date.now()-s;
}
},lastTime+(lastTime/2));
},false);
ta.value = 'i work client side too?';
drawQR('i work client side too?');
</script>
</body>
</html>

302
test/clientsideserver.js
View file

@ -1,302 +0,0 @@
var express = require('express')
,app = express.createServer()
,fs = require('fs')
,QRCode = require('../qrcode')
,canvasutil = require('canvasutil')
,Canvas = require('canvas')
,Image = Canvas.Image;
var path = require('path')
app.configure(function(){
app.use(express.methodOverride());
app.use(express.bodyParser());
app.use(app.router);
app.use(express.static(path.resolve(__dirname,'..')));
});
app.get('/', function(req, res){
fs.readFile(path.join(__dirname,'clientside.html'), function (err, data) {
res.send(data?data.toString():err);
});
});
var effectHandlers = {};
app.get('/generate', function(req, res){
var q = req.query||{},imageSrc;
QRCode.QRCodeDraw.color.light = q.lightColor||'#ffffff';
QRCode.QRCodeDraw.color.dark = q.darkColor||'#000000';
QRCode.QRCodeDraw.scale = +(q.scale);
if(isNaN(QRCode.QRCodeDraw.scale)) QRCode.QRCodeDraw.scale = 4;
//NOTE when i set scale to 500 something seg faulted
if(QRCode.QRCodeDraw.scale > 50) QRCode.QRCodeDraw.scale = 50;
var effect = q.effect||'plain';
if(!effectHandlers[effect]){
effect = 'plain';
}
effectHandlers[effect](q,function(error,canvas){
if(!error){
canvas.toBuffer(function(err, buf){
res.header('Content-Type','image/png');
res.send(buf);
});
} else {
var msg = error.message+"\n"+error.stack;
res.header('Content-Type','text/plain');
res.send(msg);
console.error(msg);
}
});
});
effectHandlers.node = function(args,cb){
args.src = path.join(__dirname,'fixtures','node_logo.png');
this.image(path.join(args,cb);
};
effectHandlers.npm = function(args,cb){
args.src = path.join(__dirname,'fixtures','npm_logo.png');
this.image(args,cb);
};
effectHandlers.bacon = function(args,cb){
args.src = path.join(__dirname,'fixtures','bacon-love.png');
this.image(args,cb);
};
effectHandlers.baconBikini = function(args,cb){
args.src = path.join(__dirname,'fixtures','bacon-bikini.png');
this.image(args,cb);
};
effectHandlers.rounded = function(args,cb){
QRCode.draw(args.text||'',function(err,canvas){
if(err) {
cb(err,canvas);
return;
}
var tpx = new canvasutil.PixelCore()
,luma709Only = canvasutil.conversionLib.luma709Only
,savedBuffer
,up=[],down=[],left=[],right=[]
,upPx,downPx,leftPx,rightPx,undefined,r,t,l,b,corner = 0;
tpx.threshold = 100;
tpx.iterate(canvas,function(px,i,len,pixels,w,h,pixelCore){
corner = 0;
//is dark
if(luma709Only(px.r,px.g,px.b) < pixelCore.threshold) {
if(i-w > 0){
upPx = (i-w)*4;
up[0] = pixels[upPx + 0];
up[1] = pixels[upPx + 1];
up[2] = pixels[upPx + 2];
//console.log('up',up);
}
if(i+w <= len) {
downPx = (i+w)*4;
down[0] = pixels[downPx + 0];
down[1] = pixels[downPx + 1];
down[2] = pixels[downPx + 2];
//console.log('down',down);
}
//have left pixel but no wrapping
if(i%w != 0){
leftPx = (i-1)*4;
left[0] = pixels[leftPx + 0];
left[1] = pixels[leftPx + 1];
left[2] = pixels[leftPx + 2];
//console.log('left',left);
}
if(i%w != w-1){
rightPx = (i+1)*4;
right[0] = pixels[rightPx + 0];
right[1] = pixels[rightPx + 1];
right[2] = pixels[rightPx + 2];
//console.log('right',right);
}
r = rightPx?luma709Only(right[0],right[1],right[2]):0;
t = upPx?luma709Only(up[0],up[1],up[2]):0;
l = leftPx?luma709Only(left[0],left[1],left[2]):0;
d = downPx?luma709Only(down[0],down[1],down[2]):0;
if(l > pixelCore.threshold){//if left is light and i am dark
if(t > pixelCore.threshold){//if top is light and i am dark
corner = 1;
pixels[rightPx + 4] = 100;
} else if(d > pixelCore.threshold){//if bottom is light and i am dark
pixels[rightPx + 4] = 100;
corner = 1;
}
} else if(r > pixelCore.threshold){
if(t > pixelCore.threshold){//if top is light and i am dark
corner = 1;
} else if(d > pixelCore.threshold){//if bottom is light and i am dark
corner = 1;
}
}
if(corner) {
px.a = 50;
}
}
});
cb(false,canvas);
});
};
effectHandlers.remoteImage = function(args,cb){
var src = args.src,domain,uri;
if(!src) {
cb(new Error('src required'),null);
} else {
if(src.indexof('://') != -1){
src = src.split('://').unshift();
var parts = src.split('/');
domain = parts.shift();
uri = parts.join('/');
}
}
if(!domain || !uri) {
cb(new Error('missing domain or uri '+args.src));
return;
}
var options = {
host: domain,
port: 80,
path: uri,
method: 'GET'
}
,req = http.request(options, function(res) {
if(res.statusCode < 200 || res.statusCode > 299){
cb(new Error('http '+res.statusCode+' response code'),null);
return;
}
res.setEncoding('utf8');
var data = '';
res.on('data', function (chunk) {
data += chunk;
console.log('BODY: ' + chunk);
});
res.on('complete',function(){
cb(false,data);
});
res.on('error',function(error){
cb(error,null);
cb = function(){};
});
});
req.end();
};
effectHandlers.image = function(args,cb){
src = args.src||'';
var img = new Image(),convert = canvasutil.conversionLib;
img.onload = function(){
QRCode.draw(args.text||'',function(err,canvas){
if(err) {
cb(err,false);
return;
}
var codeCtx = canvas.getContext('2d')
, frame = codeCtx.getImageData(0,0,canvas.width,canvas.width)
, tpx = new canvasutil.PixelCore()
, baconCanvas = new Canvas(canvas.width,canvas.width)
, ctx = baconCanvas.getContext('2d')
,topThreshold = args.darkThreshold||25
,bottomThreshold = args.lightThreshold||75;
tpx.threshold = 50;
//scale image
var w = canvas.width;
var h = canvas.height;
if(img.width>img.height) {
w = w*(canvas.height/h)
h = canvas.height;
} else {
h = h*(canvas.height/w)
w = canvas.width;
}
ctx.drawImage(img,0,0,w,h);
try{
tpx.iterate(baconCanvas,function(px,i,l,pixels,w,h,pixelCore){
var luma = (0.2125*px.r + 0.7154*px.g + 0.0721*px.b)
, codeLuma = convert.luma709Only(frame.data[i*4],frame.data[i*4+1],frame.data[i*4+2]);
if(codeLuma > pixelCore.threshold){
if(luma < bottomThreshold) {
var yuv = convert.rgbToYuv(px.r,px.g,px.b),rgb;
rgb = convert.yuvToRgb(bottomThreshold,yuv[1],yuv[2]);
px.r = rgb[0];
px.g = rgb[1];
px.b = rgb[2];
px.a = 255;
}
} else {
if(luma > topThreshold) {
var yuv = convert.rgbToYuv(px.r,px.g,px.b),rgb;
rgb = convert.yuvToRgb(topThreshold,yuv[1],yuv[2]);
px.r = rgb[0];
px.g = rgb[1];
px.b = rgb[2];
}
}
});
} catch(e){
cb(err,false);
}
cb(false,baconCanvas);
});
};
img.onerror = function(error){
error.message += ' ('+src+')';
cb(error,null);
}
img.src = src;
};
effectHandlers.plain = function(args,cb){
var text = args.text||'';
QRCode.draw(text||'',function(err,canvas){
cb(err,canvas);
});
};
app.listen(3031);
console.log('listening on 3031');

0
test/fixtures/expected-output.svg → test/e2e/fixtures/expected-output.svg
View file

Side by side Swipe

Before

(image error) Size: 17 KiB

After

(image error) Size: 17 KiB

15
test/e2e/svg.test.js Normal file
View file

@ -0,0 +1,15 @@
var test = require('tap').test
var fs = require('fs')
var path = require('path')
var QRCode = require('../../')
test('drawSvg', function (t) {
var expectedSvg = fs.readFileSync(path.join(__dirname, '/fixtures/expected-output.svg'), 'UTF-8')
QRCode.drawSvg('http://www.google.com', function (err, code) {
t.ok(!err, 'there should be no error')
t.equal(code, expectedSvg, 'should output a valid svg')
t.end()
})
})

45
test/url.js → test/e2e/url.test.js
View file

@ -1,29 +1,24 @@
var test = require('tap').test;
var test = require('tap').test
var QRCode = require('../../')
// simple tdest
var QRCode = require(__dirname+'/../qrcode.js');
var shouldBe =
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIwAAACMCAYAAACuwEE+AAAABmJLR0QA/wD/AP+gvaeTAAAC+ElEQVR4nO3dSY7bQBBFQcvw/a8s77kw/VATpY7YdosSiI9kogbW6/1+v3/Bf/p9+gfwWQSGRGBIBIZEYEgEhkRgSASGRGBIBIZEYEgEhkRgSASGRGBIBIZEYEgEhkRgSP7MvuDr9Zp9yX+6Lkm+fv/okuV6vbv/P31/RqkwJAJDIjAk03uYq9nP0Nk9wN31as9SPf3+XKkwJAJDIjAky3uYq/qMrc/4Oi4z2qOc7kF2b41XYUgEhkRgSLb3MKvVuZy7HuDu87t7nNNUGBKBIREYkq/rYa5G51Zmr6/5dCoMicCQCAzJ9h7mdA8wuiZ3tdP3544KQyIwJAJDsryH2b0P52r2vqXZc1Wn70+lwpAIDInAkLx+2nlJs3uMH3b7VBgagSERGJLj62Fmv3+l/n/tUWav6R3dh7S7x1JhSASGRGBIlr/jbvY73mY/k0d/39N6nNVUGBKBIREYkuk9zOhe5avRcZKnzfU87fdUKgyJwJAIDMny9TCre5DT4zqr58KeRoUhERgSgSHZPpd0Z/Z6j9F9RKvf8zvb6h5JhSERGBKBITm+L2n2mtTZPcuo1Wtwrenl0QSGRGBIjo/DzH5mj/6eq91zTXefP02FIREYEoEh2b4eZvZczu71Nk9/Z95qKgyJwJAIDMnycZjRz8/uWer335k9F/X0nkaFIREYEoEhOb4eZrbZ4zKze6o7q9cwj1JhSASGRGBIHjcOU9V9QqPXv/t7fd/N7OuvpsKQCAyJwJAsP2tgdk8xe25o93lJq4e9Vl9fhSERGBKBIdl+XtLoepOqngUwe+5n9V7t3VQYEoEhERiS42c+zjb7DMfd5z2N/h7jMDyKwJAIDMnX9TCr3wtc7Z47sqaXRxEYEoEh2d7D7J4LOb3G+M6n9UwqDInAkAgMyfIe5vQ+mtE1u6vPoFx95qVxGI4SGBKBIfm698OwlgpDIjAkAkMiMCQCQyIwJAJDIjAkAkMiMCQCQyIwJAJDIjAkAkMiMCQCQyIwJAJD8hcDEI4hfsS5IwAAAABJRU5ErkJggg=='
var shouldBe =
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIwAAACMCAYAAACuwEE+AAAABmJLR0QA/wD/AP+gvaeTAAAC+ElEQVR4nO3dSY7bQBBFQcvw/a8s77kw/VATpY7YdosSiI9kogbW6/1+v3/Bf/p9+gfwWQSGRGBIBIZEYEgEhkRgSASGRGBIBIZEYEgEhkRgSASGRGBIBIZEYEgEhkRgSP7MvuDr9Zp9yX+6Lkm+fv/okuV6vbv/P31/RqkwJAJDIjAk03uYq9nP0Nk9wN31as9SPf3+XKkwJAJDIjAky3uYq/qMrc/4Oi4z2qOc7kF2b41XYUgEhkRgSLb3MKvVuZy7HuDu87t7nNNUGBKBIREYkq/rYa5G51Zmr6/5dCoMicCQCAzJ9h7mdA8wuiZ3tdP3544KQyIwJAJDsryH2b0P52r2vqXZc1Wn70+lwpAIDInAkLx+2nlJs3uMH3b7VBgagSERGJLj62Fmv3+l/n/tUWav6R3dh7S7x1JhSASGRGBIlr/jbvY73mY/k0d/39N6nNVUGBKBIREYkuk9zOhe5avRcZKnzfU87fdUKgyJwJAIDMny9TCre5DT4zqr58KeRoUhERgSgSHZPpd0Z/Z6j9F9RKvf8zvb6h5JhSERGBKBITm+L2n2mtTZPcuo1Wtwrenl0QSGRGBIjo/DzH5mj/6eq91zTXefP02FIREYEoEh2b4eZvZczu71Nk9/Z95qKgyJwJAIDMnycZjRz8/uWer335k9F/X0nkaFIREYEoEhOb4eZrbZ4zKze6o7q9cwj1JhSASGRGBIHjcOU9V9QqPXv/t7fd/N7OuvpsKQCAyJwJAsP2tgdk8xe25o93lJq4e9Vl9fhSERGBKBIdl+XtLoepOqngUwe+5n9V7t3VQYEoEhERiS42c+zjb7DMfd5z2N/h7jMDyKwJAIDMnX9TCr3wtc7Z47sqaXRxEYEoEh2d7D7J4LOb3G+M6n9UwqDInAkAgMyfIe5vQ+mtE1u6vPoFx95qVxGI4SGBKBIfm698OwlgpDIjAkAkMiMCQCQyIwJAJDIjAkAkMiMCQCQyIwJAJDIjAkAkMiMCQCQyIwJAJD8hcDEI4hfsS5IwAAAABJRU5ErkJggg=="
var lShouldBe = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHwAAAB8CAYAAACrHtS+AAAABmJLR0QA/wD/AP+gvaeTAAACVUlEQVR4nO3dy27rMAwA0bro//+yu/cihEBSVDxztr15YSDw2rKT677v+0cYv9NvQHsZHMbgMAaHMTiMwWEMDmNwGIPDGBzG4DAGhzE4jMFhDA5jcBiDwxgcxuAwf9VPeF1X9VN+tHpJ3vP9PR+/+vdu1ZccusJhDA5jcJjyGf5UPYOyM7T6/Zz2+SKucBiDwxgcpn2GP63OqN3H2dmZ3P35slzhMAaHMTjM9hneLZqJ0d+jGf/tXOEwBocxOMzrZvjTafvb01zhMAaHMTjM9hk+fVwbzezs+5v+fBFXOIzBYQwO0z7Ddx/nVl93vnru/XSucBiDwxgcpnyGn34cGsnup5/OFQ5jcBiDw4zfH37a/vT0dfPdXOEwBocxOEz7cXj3ue3szN99bn31/fsdL0oxOIzBYY67Lr17pmZnaPV5ht3nIVzhMAaHMTjM+He8TB+XPq1+B8zq/ymm99td4TAGhzE4zPH3lmWPk1dfL/vvp/e7I65wGIPDGBzmuk8bMknd36de/fzuh6uVwWEMDjN+XXpW9bnp7EyNHj993b0rHMbgMAaHef3vlq3O5N3f07b73LsrHMbgMAaHGb+mLbL7t0KzM9X9cB3F4DAGhznu3rKsaL+5+n7y3Y/PcoXDGBzG4DCvm+Hd+9mr16Ttvq4+4gqHMTiMwWGOv7es+vVW7//ufj33w9XK4DAGh3nd75ZFqve3q2eyx+EqZXAYg8O87v5wfeYKhzE4jMFhDA5jcBiDwxgcxuAwBocxOIzBYQwOY3AYg8MYHMbgMAaHMTiMwWH+AWVFEfpSXe+vAAAAAElFTkSuQmCC'
test('qrcode to data uri should be correct.', function (t) {
QRCode.toDataURL('i am a pony!', function (err, url) {
if (err) console.log(err)
t.ok(!err, 'there should be no error ' + err)
t.equals(url, shouldBe, 'url generated should match expected value')
t.end()
})
})
var lShouldBe = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHwAAAB8CAYAAACrHtS+AAAABmJLR0QA/wD/AP+gvaeTAAACVUlEQVR4nO3dy27rMAwA0bro//+yu/cihEBSVDxztr15YSDw2rKT677v+0cYv9NvQHsZHMbgMAaHMTiMwWEMDmNwGIPDGBzG4DAGhzE4jMFhDA5jcBiDwxgcxuAwf9VPeF1X9VN+tHpJ3vP9PR+/+vdu1ZccusJhDA5jcJjyGf5UPYOyM7T6/Zz2+SKucBiDwxgcpn2GP63OqN3H2dmZ3P35slzhMAaHMTjM9hneLZqJ0d+jGf/tXOEwBocxOMzrZvjTafvb01zhMAaHMTjM9hk+fVwbzezs+5v+fBFXOIzBYQwO0z7Ddx/nVl93vnru/XSucBiDwxgcpnyGn34cGsnup5/OFQ5jcBiDw4zfH37a/vT0dfPdXOEwBocxOEz7cXj3ue3szN99bn31/fsdL0oxOIzBYY67Lr17pmZnaPV5ht3nIVzhMAaHMTjM+He8TB+XPq1+B8zq/ymm99td4TAGhzE4zPH3lmWPk1dfL/vvp/e7I65wGIPDGBzmuk8bMknd36de/fzuh6uVwWEMDjN+XXpW9bnp7EyNHj993b0rHMbgMAaHef3vlq3O5N3f07b73LsrHMbgMAaHGb+mLbL7t0KzM9X9cB3F4DAGhznu3rKsaL+5+n7y3Y/PcoXDGBzG4DCvm+Hd+9mr16Ttvq4+4gqHMTiMwWGOv7es+vVW7//ufj33w9XK4DAGh3nd75ZFqve3q2eyx+EqZXAYg8O87v5wfeYKhzE4jMFhDA5jcBiDwxgcxuAwBocxOIzBYQwOY3AYg8MYHMbgMAaHMTiMwWH+AWVFEfpSXe+vAAAAAElFTkSuQmCC"
test('qrcode to data uri should be correct.',function(t){
QRCode.toDataURL('i am a pony!',function(err,url){
if(err) console.log(err);
t.ok(!err,'there should be no error '+err);
t.equals(url,shouldBe,"url generated should match expected value");
t.end();
});
});
test('qrcode generated with changed error correction should be expected value',function(t){
QRCode.toDataURL('i am a pony!',{errorCorrectLevel:'minimum'},function(err,url){
t.ok(!err,'there should be no error '+err);
t.equals(url,lShouldBe,"url should match expected value for error correction L");
t.end();
});
});
test('qrcode generated with changed error correction should be expected value', function (t) {
QRCode.toDataURL('i am a pony!', {errorCorrectLevel: 'minimum'}, function (err, url) {
t.ok(!err, 'there should be no error ' + err)
t.equals(url, lShouldBe, 'url should match expected value for error correction L')
t.end()
})
})

14
test/save.js
View file

@ -1,14 +0,0 @@
var QRCode = require(__dirname+'/../qrcode')
, fs = require('fs')
, util = require('util');
var path = './tmp.png';
QRCode.save(path,'life of the party bros',function(error,written){
if(error) {
console.log(error);
} else {
util.print(written == (fs.statSync(path)||{}).size?"PASS: written should be to the correct file\n":"FAIL: file should be written size\n");
fs.unlinkSync(path);
}
});

35
test/server.js
View file

@ -1,35 +0,0 @@
var QRCode = require(__dirname+'/../qrcode')
, connect = require('express');
function testQRCode(req, res) {
res.writeHead(200, { 'Content-Type': 'text/html' });
var jungleBook = "The moonlight was blocked out of the mouth of the cave, for Shere Khan's\n"
+"great square head and shoulders were thrust into the entrance. Tabaqui,\n"
+"behind him, was squeaking: \"My lord, my lord, it went in here!\"\n"
+"\n"
+"\"Shere Khan does us great honor,\" said Father Wolf, but his eyes were\n"
+"very angry. \"What does Shere Khan need?\"\n"
+"\n"
+"\"My quarry. A man's cub went this way,\" said Shere Khan. \"Its parents\n"
+"have run off. Give it to me.\"\n"
+"\n"
+"Shere Khan had jumped at a woodcutter's campfire, as Father Wolf had\n"
+"said, and was furious from the pain of his burned feet. But Father Wolf\n"
+"knew that the mouth of the cave was too narrow for a tiger to come in\n"
+"by. Even where he was, Shere Khan's shoulders and forepaws were cramped\n"
+"for want of room, as a man's would be if he tried to fight in a barrel.\n"
+"\n"
+"\"The Wolves are a free people,\" said Father Wolf. \"They take orders from\n"
+"the Head of the Pack, and not from any striped cattle-killer. The man's\n"
+"cub is ours--to kill if we choose.\"";
//QRCode.QRCodeDraw.color.dark = '#d4d4d4';
QRCode.toDataURL(jungleBook,function(err,url){
if(err) console.log('error: '+err);
res.end("<!DOCTYPE html/><html><head><title>node-qrcode</title></head><body><img src='"+url+"'/></body></html>");
});
}
connect.createServer(testQRCode).listen(3030);
console.log('test server started on port 3030');

81
test/svg.js
View file

@ -1,81 +0,0 @@
var test = require('tap').test;
var libxml = require("libxmljs");
var fs = require('fs');
var svgRender = require('../lib/svgrender');
var QRCode = require('../qrcode');
test('svgrender interface', function(t) {
t.ok(svgRender.hasOwnProperty('renderBits'), 'function "renderBits" should be defined');
t.throws(function() { svgrender.renderBits(); }, 'should throws if called without params');
t.throws(function() { svgrender.renderBits([]); }, 'should throws if called without "width" param');
t.throws(function() { svgrender.renderBits([], ""); }, 'should throws if called with invalid "width" param');
t.throws(function() { svgrender.renderBits(null, 0); }, 'should throws if called with undefined "bits" param');
t.throws(function() { svgrender.renderBits("", 0); }, 'should throws if "bits" param is not an array');
t.end();
});
test('svgrender output', function(t) {
var expectedWidth = 2;
var expectedMargin = 8;
var expectedScale = 5;
var expectedQrCodeSize = '26'; // qrcode size = width * scale + margin * 2
var expectedLightColor = '#AAAAAA';
var expectedDarkColor = '#555555';
var bits = [1, 1, 0, 1];
var expectedTrueBitNumber = bits.filter(function(b) { return b; }).length;
var xml = svgRender.renderBits(bits, expectedWidth, {
scale: expectedScale,
margin: expectedMargin,
lightColor: expectedLightColor,
darkColor: expectedDarkColor
});
var xmlDoc = libxml.parseXml(xml);
t.equal(xmlDoc.errors.length, 0, 'should output a valid xml');
var rootElem = xmlDoc.root();
t.equal('svg', rootElem.name(), 'should have <svg> has root element');
t.equal(rootElem.attr('width').value(), expectedQrCodeSize, 'should have a valid width');
t.equal(rootElem.attr('height').value(), expectedQrCodeSize, 'should have a valid height');
var rectElem = rootElem.child(1);
t.equal(rectElem.name(), 'rect', 'should have <rect> as first child element');
t.equal(rectElem.attr('width').value(), expectedQrCodeSize, 'should have a valid rect width');
t.equal(rectElem.attr('height').value(), expectedQrCodeSize, 'should have a valid rect height');
t.equal(rectElem.attr('fill').value(), expectedLightColor, 'should have the background color specified in options');
var dotDef = rectElem.nextElement();
t.equal(dotDef.name(), 'defs', 'should have a <defs> element');
var dotRect = dotDef.child(0);
t.equal(dotRect.name(), 'rect', 'should have a <rect> definition');
t.equal(dotRect.attr('width').value(), expectedScale.toString(), 'should have a valid rect width');
t.equal(dotRect.attr('height').value(), expectedScale.toString(), 'should have a valid rect height');
var gElem = dotDef.nextElement();
t.equal(gElem.name(), 'g', 'should have a <g> element');
t.equal(gElem.attr('fill').value(), expectedDarkColor, 'should have the color specified in options');
var useElems = gElem.find('*');
t.equal(useElems.length, expectedTrueBitNumber, 'should have one element for each "true" bit');
t.equal(useElems[0].attr('x').value(), expectedMargin.toString(), 'should have a left margin as specified in options');
t.equal(useElems[0].attr('y').value(), expectedMargin.toString(), 'should have a top margin as specified in options');
t.end();
});
test('drawSvg', function(t) {
var expectedSvg = fs.readFileSync(__dirname + '/fixtures/expected-output.svg', 'UTF-8');
QRCode.drawSvg('http://www.google.com', function(err, code) {
t.ok(!err, 'there should be no error');
t.equal(code, expectedSvg, 'should output a valid svg');
t.end()
});
});

79
test/unit/core/alignment-pattern.test.js Executable file
View file

@ -0,0 +1,79 @@
var test = require('tap').test
var pattern = require('core/alignment-pattern')
/**
* Row/column coordinates of the center module of each alignment pattern.
* Each sub-array refers to a qr code version.
*
* @type {Array}
*/
var EXPECTED_POSITION_TABLE = [
[],
[6, 18],
[6, 22],
[6, 26],
[6, 30],
[6, 34],
[6, 22, 38],
[6, 24, 42],
[6, 26, 46],
[6, 28, 50],
[6, 30, 54],
[6, 32, 58],
[6, 34, 62],
[6, 26, 46, 66],
[6, 26, 48, 70],
[6, 26, 50, 74],
[6, 30, 54, 78],
[6, 30, 56, 82],
[6, 30, 58, 86],
[6, 34, 62, 90],
[6, 28, 50, 72, 94],
[6, 26, 50, 74, 98],
[6, 30, 54, 78, 102],
[6, 28, 54, 80, 106],
[6, 32, 58, 84, 110],
[6, 30, 58, 86, 114],
[6, 34, 62, 90, 118],
[6, 26, 50, 74, 98, 122],
[6, 30, 54, 78, 102, 126],
[6, 26, 52, 78, 104, 130],
[6, 30, 56, 82, 108, 134],
[6, 34, 60, 86, 112, 138],
[6, 30, 58, 86, 114, 142],
[6, 34, 62, 90, 118, 146],
[6, 30, 54, 78, 102, 126, 150],
[6, 24, 50, 76, 102, 128, 154],
[6, 28, 54, 80, 106, 132, 158],
[6, 32, 58, 84, 110, 136, 162],
[6, 26, 54, 82, 110, 138, 166],
[6, 30, 58, 86, 114, 142, 170]
]
test('Alignment pattern - Row/Col coords', function (t) {
t.plan(40)
for (var i = 1; i <= 40; i++) {
var pos = pattern.getRowColCoords(i)
t.deepEqual(pos, EXPECTED_POSITION_TABLE[i - 1], 'Should return correct coords')
}
})
test('Alignment pattern - Positions', function (t) {
for (var i = 1; i <= 40; i++) {
var pos = pattern.getPositions(i)
var expectedPos = EXPECTED_POSITION_TABLE[i - 1]
var expectedLength = (Math.pow(expectedPos.length, 2) || 3) - 3
t.equal(pos.length, expectedLength, 'Should return correct number of positions')
// For each coord value check if it's present in the expected coords table
pos.forEach(function (position) {
position.forEach(function (coord) {
t.notEqual(expectedPos.indexOf(coord), -1, 'Should return valid coord value')
})
})
}
t.end()
})

20
test/unit/core/bit-buffer.test.js Normal file
View file

@ -0,0 +1,20 @@
var test = require('tap').test
var BitBuffer = require('core/bit-buffer')
test('Bit Buffer', function (t) {
var testData = 0x41 // 'A'
var expectedDataBits = [false, true, false, false, false, false, false, true]
var bitBuffer = new BitBuffer()
t.equal(bitBuffer.getLengthInBits(), 0, 'Initial length should be 0')
bitBuffer.put(testData, 8)
t.equal(bitBuffer.getLengthInBits(), 8, 'Length should be 8')
for (var i = 0; i < 8; i++) {
t.deepEqual(bitBuffer.get(i), expectedDataBits[i], 'Should return correct bit value')
}
t.end()
})

24
test/unit/core/bit-matrix.test.js Normal file
View file

@ -0,0 +1,24 @@
var test = require('tap').test
var BitMatrix = require('core/bit-matrix')
test('Bit Matrix', function (t) {
t.throw(function () { BitMatrix(0) }, 'Should throw if size is 0')
t.throw(function () { BitMatrix(-1) }, 'Should throw if size less than 0')
var bm = new BitMatrix(2)
t.equal(bm.size, 2, 'Should have correct size')
t.equal(bm.data.length, 4, 'Should correctly set buffer size')
bm.set(0, 1, true, true)
t.ok(bm.get(0, 1), 'Should correctly set bit to true')
t.ok(bm.isReserved(0, 1), 'Should correctly set bit as reserved')
bm.xor(0, 1, 1)
t.ok(!bm.get(0, 1), 'Should correctly xor bit')
bm.set(0, 1, false)
t.notOk(bm.get(0, 1), 'Should correctly set bit to false')
t.end()
})

36
test/unit/core/byte-data.test.js Normal file
View file

@ -0,0 +1,36 @@
var test = require('tap').test
var BitBuffer = require('core/bit-buffer')
var ByteData = require('core/byte-data')
var Mode = require('core/mode')
test('Byte Data', function (t) {
var text = '1234'
var textByte = [49, 50, 51, 52] // 1, 2, 3, 4
var utf8Text = '\u00bd + \u00bc = \u00be' // 9 char, 12 byte
var byteData = new ByteData(text)
t.equal(byteData.mode, Mode.BYTE, 'Mode should be BYTE')
t.equal(byteData.getLength(), text.length, 'Should return correct length')
t.ok(ByteData.getCharCountIndicator, 'getCharCountIndicator should be defined')
for (var v = 1; v <= 40; v++) {
t.ok(byteData.getCharCountIndicator(v), 'Should return a positive number')
}
t.throw(function () { byteData.getCharCountIndicator(0) }, 'Should throw if invalid version')
var bitBuffer = new BitBuffer()
byteData.write(bitBuffer)
t.deepEqual(bitBuffer.buffer, textByte, 'Should write correct data to buffer')
byteData.append(text)
t.equal(byteData.getLength(), text.length * 2, 'Should return correct length')
t.deepEqual(byteData.data, new Buffer(textByte.concat(textByte)), 'Should correctly append data')
var byteDataUtf8 = new ByteData(utf8Text)
t.equal(byteDataUtf8.getLength(), 12, 'Should return correct length for utf8 chars')
t.end()
})

44
test/unit/core/error-correction-code.test.js Normal file
View file

@ -0,0 +1,44 @@
var test = require('tap').test
var Utils = require('core/utils')
var Version = require('core/version')
var ECLevel = require('core/error-correction-level')
var ECCode = require('core/error-correction-code')
var ByteData = require('core/byte-data')
test('Error correction codewords', function (t) {
var levels = [ECLevel.L, ECLevel.M, ECLevel.Q, ECLevel.H]
for (var v = 1; v <= 40; v++) {
var totalCodewords = Utils.getSymbolTotalCodewords(v)
var reservedByte = Math.ceil((ByteData.getCharCountIndicator(v) + 4) / 8)
for (var l = 0; l < levels.length; l++) {
var dataCodewords = Version.getCapacity(v, levels[l]) + reservedByte
var expectedCodewords = totalCodewords - dataCodewords
t.equal(ECCode.getTotalCodewordsCount(v, levels[l]), expectedCodewords,
'Should return correct codewords number')
}
}
t.equal(ECCode.getTotalCodewordsCount(1), undefined,
'Should return undefined if EC level is not specified')
t.end()
})
test('Error correction blocks', function (t) {
var levels = [ECLevel.L, ECLevel.M, ECLevel.Q, ECLevel.H]
for (var v = 1; v <= 40; v++) {
for (var l = 0; l < levels.length; l++) {
t.ok(ECCode.getBlocksCount(v, levels[l]), 'Should return a positive number')
}
}
t.equal(ECCode.getBlocksCount(1), undefined,
'Should return undefined if EC level is not specified')
t.end()
})

10
test/unit/core/finder-pattern.test.js Executable file
View file

@ -0,0 +1,10 @@
var test = require('tap').test
var pattern = require('core/finder-pattern')
test('Finder pattern', function (t) {
for (var i = 1; i <= 40; i++) {
t.equal(pattern.getPositions(i).length, 3, 'Should always return 3 pattern positions')
}
t.end()
})

25
test/unit/core/format-info.test.js Normal file
View file

@ -0,0 +1,25 @@
var test = require('tap').test
var FormatInfo = require('core/format-info')
var ECLevel = require('core/error-correction-level')
var MaskPattern = require('core/mask-pattern')
var EXPECTED_FORMAT_BITS = [
[0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976],
[0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0],
[0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed],
[0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b]
]
test('Format encoded info', function (t) {
var levels = [ECLevel.L, ECLevel.M, ECLevel.Q, ECLevel.H]
var patterns = Object.keys(MaskPattern.Patterns).length
for (var l = 0; l < levels.length; l++) {
for (var p = 0; p < patterns; p++) {
var bch = FormatInfo.getEncodedBits(levels[l], p)
t.equal(bch, EXPECTED_FORMAT_BITS[l][p], 'Should return correct bits')
}
}
t.end()
})

21
test/unit/core/galois-field.test.js Normal file
View file

@ -0,0 +1,21 @@
var test = require('tap').test
var GF = require('core/galois-field')
test('Galois Field', function (t) {
t.throw(function () { GF.log(0) }, 'Should throw for log(n) with n < 1')
for (var i = 1; i < 255; i++) {
t.equal(GF.log(GF.exp(i)), i, 'log and exp should be one the inverse of the other')
t.equal(GF.exp(GF.log(i)), i, 'exp and log should be one the inverse of the other')
}
t.equal(GF.mul(0, 1), 0, 'Should return 0 if first param is 0')
t.equal(GF.mul(1, 0), 0, 'Should return 0 if second param is 0')
t.equal(GF.mul(0, 0), 0, 'Should return 0 if both params are 0')
for (var j = 1; j < 255; j++) {
t.equal(GF.mul(j, 255 - j), GF.mul(255 - j, j), 'Multiplication should be commutative')
}
t.end()
})

123
test/unit/core/mask-pattern.test.js Executable file
View file

@ -0,0 +1,123 @@
var test = require('tap').test
var BitMatrix = require('core/bit-matrix')
var MaskPattern = require('core/mask-pattern')
test('Mask pattern - Pattern references', function (t) {
var patternsCount = Object.keys(MaskPattern.Patterns).length
t.equals(patternsCount, 8, 'Should return 8 patterns')
t.end()
})
var expectedPattern000 = [
1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 0, 1,
1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 0, 1,
1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 0, 1
]
var expectedPattern001 = [
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0
]
var expectedPattern010 = [
1, 0, 0, 1, 0, 0,
1, 0, 0, 1, 0, 0,
1, 0, 0, 1, 0, 0,
1, 0, 0, 1, 0, 0,
1, 0, 0, 1, 0, 0,
1, 0, 0, 1, 0, 0
]
var expectedPattern011 = [
1, 0, 0, 1, 0, 0,
0, 0, 1, 0, 0, 1,
0, 1, 0, 0, 1, 0,
1, 0, 0, 1, 0, 0,
0, 0, 1, 0, 0, 1,
0, 1, 0, 0, 1, 0
]
var expectedPattern100 = [
1, 1, 1, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 1, 1, 1,
1, 1, 1, 0, 0, 0,
1, 1, 1, 0, 0, 0
]
var expectedPattern101 = [
1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0,
1, 0, 0, 1, 0, 0,
1, 0, 1, 0, 1, 0,
1, 0, 0, 1, 0, 0,
1, 0, 0, 0, 0, 0
]
var expectedPattern110 = [
1, 1, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0,
1, 1, 0, 1, 1, 0,
1, 0, 1, 0, 1, 0,
1, 0, 1, 1, 0, 1,
1, 0, 0, 0, 1, 1
]
var expectedPattern111 = [
1, 0, 1, 0, 1, 0,
0, 0, 0, 1, 1, 1,
1, 0, 0, 0, 1, 1,
0, 1, 0, 1, 0, 1,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0
]
test('Mask pattern - Apply mask', function (t) {
var patterns = Object.keys(MaskPattern.Patterns).length
var expectedPatterns = [
expectedPattern000, expectedPattern001, expectedPattern010, expectedPattern011,
expectedPattern100, expectedPattern101, expectedPattern110, expectedPattern111
]
for (var p = 0; p < patterns; p++) {
var matrix = new BitMatrix(6)
MaskPattern.applyMask(p, matrix)
t.deepEqual(matrix.data, new Buffer(expectedPatterns[p]), 'Should return correct pattern')
}
matrix = new BitMatrix(2)
matrix.set(0, 0, false, true)
matrix.set(0, 1, false, true)
matrix.set(1, 0, false, true)
matrix.set(1, 1, false, true)
MaskPattern.applyMask(0, matrix)
t.deepEqual(matrix.data, new Buffer([false, false, false, false]), 'Should leave reserved bit unchanged')
t.throws(function () { MaskPattern.applyMask(-1, new BitMatrix(1)) }, 'Should throw if pattern is invalid')
t.end()
})
test('Mask pattern - Best mask', function (t) {
var matrix = new BitMatrix(7)
// Draw a pattern with ratio 1:1:3:1:1 to test penality N3
matrix.set(0, 1, true)
matrix.set(0, 5, true)
matrix.set(1, 0, true)
matrix.set(5, 0, true)
var mask = MaskPattern.getBestMask(matrix)
t.ok(!isNaN(mask), 'Should return a number')
t.end()
})

29
test/unit/core/polynomial.test.js Normal file
View file

@ -0,0 +1,29 @@
var test = require('tap').test
var Poly = require('core/polynomial')
test('Generator polynomial', function (t) {
var result = Poly.generateECPolynomial(0)
t.ok(Buffer.isBuffer(result), 'Should return a buffer')
t.deepEqual(result, new Buffer([1]), 'Should return coeff [1] for polynomial of degree 0')
for (var e = 2; e <= 68; e++) {
t.equal(Poly.generateECPolynomial(e).length, e + 1, 'Should return a number of coefficients equal to (degree + 1)')
}
t.end()
})
test('Polynomial', function (t) {
var p1 = [0, 1, 2, 3, 4]
var p2 = [5, 6]
var result = Poly.mul(p1, p2)
t.ok(Buffer.isBuffer(result), 'Should return a buffer')
t.equal(result.length, 6, 'Should return correct number of coefficients')
result = Poly.mod(p1, Poly.generateECPolynomial(2))
t.ok(Buffer.isBuffer(result), 'Should return a buffer')
t.equal(result.length, 2, 'Should return correct number of coefficients')
t.end()
})

49
test/unit/core/qrcode.test.js Normal file
View file

@ -0,0 +1,49 @@
var test = require('tap').test
var ByteData = require('core/byte-data')
var ECLevel = require('core/error-correction-level')
var Version = require('core/version')
var QRCode = require('core/qrcode')
test('QRCode interface', function (t) {
var qr
t.notThrow(function () { qr = new QRCode() }, 'Should not throw')
qr.addData('1234567')
t.ok(qr.data instanceof ByteData, 'Should add data in correct mode')
qr.make()
t.equal(qr.version, 1, 'Should create qrcode with correct version')
t.equal(qr.getModuleCount(), 21, 'Should return correct modules count')
t.equal(qr.errorCorrectionLevel, ECLevel.H, 'Should set default EC level to H')
var outOfBoundCoords = [
[0, 22], [22, 0], [22, 22], [-1, 0], [0, -1]
]
outOfBoundCoords.forEach(function (c) {
t.throw(function () { qr.isDark(c[0], c[1]) }, 'Should throw with wrong coords')
})
var darkModule = qr.isDark(qr.getModuleCount() - 8, 8)
t.ok(darkModule, 'Should have a dark module at coords [size-8][8]')
t.end()
})
test('QRCode version', function (t) {
var qr = new QRCode(7, ECLevel.L)
qr.addData('data')
qr.make()
t.equal(qr.version, 7, 'Should create qrcode with correct version')
t.equal(qr.errorCorrectionLevel, ECLevel.L, 'Should set correct EC level')
qr = new QRCode(1, ECLevel.H)
qr.addData(new Array(Version.getCapacity(2, ECLevel.H)).join('-'))
t.throw(function () { qr.make() }, 'Should throw if data cannot be contained with chosen version')
qr = new QRCode(40, ECLevel.H)
qr.addData(new Array(Version.getCapacity(40, ECLevel.H) + 2).join('-'))
t.throw(function () { qr.make() }, 'Should throw if data cannot be contained in a qr code')
t.end()
})

29
test/unit/core/reed-solomon-encoder.test.js Normal file
View file

@ -0,0 +1,29 @@
var test = require('tap').test
var RS = require('core/reed-solomon-encoder')
test('Reed-Solomon encoder', function (t) {
var enc = new RS()
t.notOk(enc.genPoly, 'Should have an undefined generator polynomial')
t.throw(function () { enc.encode([]) }, 'Should throw if generator polynomial is undefined')
enc.initialize(2)
t.equal(enc.degree, 2, 'Should set correct degree value')
t.ok(enc.genPoly, 'Generator polynomial should be defined')
var result = enc.encode(new Buffer('01234'))
t.equal(result.length, 2, 'Should return a number of codewords equal to gen poly degree')
enc = new RS(2)
var genPoly = enc.genPoly
t.equal(enc.degree, 2, 'Should set correct degree value')
t.ok(genPoly, 'Generator polynomial should be defined')
enc.initialize(3)
t.notEqual(enc.genPoly, genPoly, 'Should reinitialize the generator polynomial')
enc = new RS(0)
t.notOk(enc.genPoly, 'Should not create a generator polynomial if degree is 0')
t.end()
})

34
test/unit/core/utils.test.js Executable file
View file

@ -0,0 +1,34 @@
var test = require('tap').test
var utils = require('core/utils')
/**
* QR Code sizes. Each element refers to a version
* @type {Array}
*/
var EXPECTED_SYMBOL_SIZES = [
21, 25, 29, 33, 37, 41, 45,
49, 53, 57, 61, 65, 69, 73,
77, 81, 85, 89, 93, 97, 101,
105, 109, 113, 117, 121, 125,
129, 133, 137, 141, 145, 149,
153, 157, 161, 165, 169, 173, 177]
test('Symbol size', function (t) {
t.throws(function () { utils.getSymbolSize() }, 'Should throw if version is undefined')
t.throws(function () { utils.getSymbolSize(0) }, 'Should throw if version is not in range')
t.throws(function () { utils.getSymbolSize(41) }, 'Should throw if version is not in range')
for (var i = 1; i <= 40; i++) {
t.equal(utils.getSymbolSize(i), EXPECTED_SYMBOL_SIZES[i - 1], 'Should return correct symbol size')
}
t.end()
})
test('Symbol codewords', function (t) {
for (var i = 1; i <= 40; i++) {
t.ok(utils.getSymbolTotalCodewords(i), 'Should return positive number')
}
t.end()
})

136
test/unit/core/version.test.js Normal file
View file

@ -0,0 +1,136 @@
var test = require('tap').test
var Version = require('core/version')
var ECLevel = require('core/error-correction-level')
var ByteData = require('core/byte-data')
var EXPECTED_CAPACITY = [
[17, 14, 11, 7],
[32, 26, 20, 14],
[53, 42, 32, 24],
[78, 62, 46, 34],
[106, 84, 60, 44],
[134, 106, 74, 58],
[154, 122, 86, 64],
[192, 152, 108, 84],
[230, 180, 130, 98],
[271, 213, 151, 119],
[321, 251, 177, 137],
[367, 287, 203, 155],
[425, 331, 241, 177],
[458, 362, 258, 194],
[520, 412, 292, 220],
[586, 450, 322, 250],
[644, 504, 364, 280],
[718, 560, 394, 310],
[792, 624, 442, 338],
[858, 666, 482, 382],
[929, 711, 509, 403],
[1003, 779, 565, 439],
[1091, 857, 611, 461],
[1171, 911, 661, 511],
[1273, 997, 715, 535],
[1367, 1059, 751, 593],
[1465, 1125, 805, 625],
[1528, 1190, 868, 658],
[1628, 1264, 908, 698],
[1732, 1370, 982, 742],
[1840, 1452, 1030, 790],
[1952, 1538, 1112, 842],
[2068, 1628, 1168, 898],
[2188, 1722, 1228, 958],
[2303, 1809, 1283, 983],
[2431, 1911, 1351, 1051],
[2563, 1989, 1423, 1093],
[2699, 2099, 1499, 1139],
[2809, 2213, 1579, 1219],
[2953, 2331, 1663, 1273]
]
var EXPECTED_VERSION_BITS = [
0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6, 0x0C762, 0x0D847, 0x0E60D,
0x0F928, 0x10B78, 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683, 0x168C9,
0x177EC, 0x18EC4, 0x191E1, 0x1AFAB, 0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75,
0x1F250, 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B, 0x2542E, 0x26A64,
0x27541, 0x28C69
]
test('Version validity', function (t) {
t.notOk(Version.isValidVersion(), 'Should return false if no input')
t.notOk(Version.isValidVersion(''), 'Should return false if version is not a number')
t.notOk(Version.isValidVersion(0), 'Should return false if version is not in range')
t.notOk(Version.isValidVersion(41), 'Should return false if version is not in range')
t.end()
})
test('Version capacity', function (t) {
t.throws(function () { Version.getCapacity() }, 'Should throw if version is undefined')
t.throws(function () { Version.getCapacity('') }, 'Should throw if version is not a number')
t.throws(function () { Version.getCapacity(0) }, 'Should throw if version is not in range')
t.throws(function () { Version.getCapacity(41) }, 'Should throw if version is not in range')
for (var i = 1; i <= 40; i++) {
t.equal(Version.getCapacity(i, ECLevel.L), EXPECTED_CAPACITY[i - 1][0], 'Should return correct capacity')
t.equal(Version.getCapacity(i, ECLevel.M), EXPECTED_CAPACITY[i - 1][1], 'Should return correct capacity')
t.equal(Version.getCapacity(i, ECLevel.Q), EXPECTED_CAPACITY[i - 1][2], 'Should return correct capacity')
t.equal(Version.getCapacity(i, ECLevel.H), EXPECTED_CAPACITY[i - 1][3], 'Should return correct capacity')
}
t.end()
})
test('Version best match', function (t) {
var levels = [ECLevel.L, ECLevel.M, ECLevel.Q, ECLevel.H]
for (var v = 0; v < 40; v++) {
for (var l = 0; l < levels.length; l++) {
var capacity = EXPECTED_CAPACITY[v][l]
var dataArray = new Array(capacity)
var dataString = new Array(capacity + 1).join(' ')
var dataBuffer = new Buffer(capacity)
var byteData = new ByteData(new Array(capacity))
t.equal(Version.getBestVersionForData(dataArray, levels[l]), v + 1, 'Should return best version')
t.equal(Version.getBestVersionForData(dataString, levels[l]), v + 1, 'Should return best version')
t.equal(Version.getBestVersionForData(dataBuffer, levels[l]), v + 1, 'Should return best version')
t.equal(Version.getBestVersionForData(byteData, levels[l]), v + 1, 'Should return best version')
if (l === 3) {
t.deepEqual(Version.getBestVersionForData(dataArray), v + 1, 'Should return best version for ECLevel.H if error level is undefined')
t.deepEqual(Version.getBestVersionForData(dataString), v + 1, 'Should return best version for ECLevel.H if error level is undefined')
t.deepEqual(Version.getBestVersionForData(dataBuffer), v + 1, 'Should return best version for ECLevel.H if error level is undefined')
t.deepEqual(Version.getBestVersionForData(byteData), v + 1, 'Should return best version for ECLevel.H if error level is undefined')
}
}
}
for (var i = 0; i < levels.length; i++) {
var exceededCapacity = EXPECTED_CAPACITY[39][i] + 1
var tooBigDataArray = new Array(exceededCapacity)
var tooBigDataString = new Array(exceededCapacity + 1).join('-')
var tooBigDataBuffer = new Buffer(exceededCapacity)
var tooBigByteData = new ByteData(new Array(exceededCapacity))
t.notOk(Version.getBestVersionForData(tooBigDataArray, levels[i]), 'Should return undefined if data is too big')
t.notOk(Version.getBestVersionForData(tooBigDataString, levels[i]), 'Should return undefined if data is too big')
t.notOk(Version.getBestVersionForData(tooBigDataBuffer, levels[i]), 'Should return undefined if data is too big')
t.notOk(Version.getBestVersionForData(tooBigByteData, levels[i]), 'Should return undefined if data is too big')
}
t.end()
})
test('Version encoded info', function (t) {
var v
for (v = 0; v < 7; v++) {
t.throws(function () { Version.getEncodedBits(v) }, 'Should throw if version is invalid or less than 7')
}
for (v = 7; v <= 40; v++) {
var bch = Version.getEncodedBits(v)
t.equal(bch, EXPECTED_VERSION_BITS[v - 7], 'Should return correct bits')
}
t.end()
})

67
test/unit/renderer/svg.test.js Normal file
View file

@ -0,0 +1,67 @@
var test = require('tap').test
var libxml = require('libxmljs')
var svgRender = require('renderer/svg')
test('svgrender interface', function (t) {
t.ok(svgRender.hasOwnProperty('renderBits'), 'function "renderBits" should be defined')
t.throws(function () { svgRender.renderBits() }, 'should throws if called without params')
t.throws(function () { svgRender.renderBits([]) }, 'should throws if called without "width" param')
t.throws(function () { svgRender.renderBits([], '') }, 'should throws if called with invalid "width" param')
t.throws(function () { svgRender.renderBits(null, 0) }, 'should throws if called with undefined "bits" param')
t.throws(function () { svgRender.renderBits('', 0) }, 'should throws if "bits" param is not an array')
t.end()
})
test('svgrender output', function (t) {
var expectedWidth = 2
var expectedMargin = 8
var expectedScale = 5
var expectedQrCodeSize = '26' // qrcode size = width * scale + margin * 2
var expectedLightColor = '#AAAAAA'
var expectedDarkColor = '#555555'
var bits = [1, 1, 0, 1]
var expectedTrueBitNumber = bits.filter(function (b) { return b }).length
var xml = svgRender.renderBits(bits, expectedWidth, {
scale: expectedScale,
margin: expectedMargin,
lightColor: expectedLightColor,
darkColor: expectedDarkColor
})
var xmlDoc = libxml.parseXml(xml)
t.equal(xmlDoc.errors.length, 0, 'should output a valid xml')
var rootElem = xmlDoc.root()
t.equal('svg', rootElem.name(), 'should have <svg> has root element')
t.equal(rootElem.attr('width').value(), expectedQrCodeSize, 'should have a valid width')
t.equal(rootElem.attr('height').value(), expectedQrCodeSize, 'should have a valid height')
var rectElem = rootElem.child(1)
t.equal(rectElem.name(), 'rect', 'should have <rect> as first child element')
t.equal(rectElem.attr('width').value(), expectedQrCodeSize, 'should have a valid rect width')
t.equal(rectElem.attr('height').value(), expectedQrCodeSize, 'should have a valid rect height')
t.equal(rectElem.attr('fill').value(), expectedLightColor, 'should have the background color specified in options')
var dotDef = rectElem.nextElement()
t.equal(dotDef.name(), 'defs', 'should have a <defs> element')
var dotRect = dotDef.child(0)
t.equal(dotRect.name(), 'rect', 'should have a <rect> definition')
t.equal(dotRect.attr('width').value(), expectedScale.toString(), 'should have a valid rect width')
t.equal(dotRect.attr('height').value(), expectedScale.toString(), 'should have a valid rect height')
var gElem = dotDef.nextElement()
t.equal(gElem.name(), 'g', 'should have a <g> element')
t.equal(gElem.attr('fill').value(), expectedDarkColor, 'should have the color specified in options')
var useElems = gElem.find('*')
t.equal(useElems.length, expectedTrueBitNumber, 'should have one element for each "true" bit')
t.equal(useElems[0].attr('x').value(), expectedMargin.toString(), 'should have a left margin as specified in options')
t.equal(useElems[0].attr('y').value(), expectedMargin.toString(), 'should have a top margin as specified in options')
t.end()
})