const Mode = require('./mode')
|
const NumericData = require('./numeric-data')
|
const AlphanumericData = require('./alphanumeric-data')
|
const ByteData = require('./byte-data')
|
const KanjiData = require('./kanji-data')
|
const Regex = require('./regex')
|
const Utils = require('./utils')
|
const dijkstra = require('dijkstrajs')
|
|
/**
|
* Returns UTF8 byte length
|
*
|
* @param {String} str Input string
|
* @return {Number} Number of byte
|
*/
|
function getStringByteLength (str) {
|
return unescape(encodeURIComponent(str)).length
|
}
|
|
/**
|
* Get a list of segments of the specified mode
|
* from a string
|
*
|
* @param {Mode} mode Segment mode
|
* @param {String} str String to process
|
* @return {Array} Array of object with segments data
|
*/
|
function getSegments (regex, mode, str) {
|
const segments = []
|
let result
|
|
while ((result = regex.exec(str)) !== null) {
|
segments.push({
|
data: result[0],
|
index: result.index,
|
mode: mode,
|
length: result[0].length
|
})
|
}
|
|
return segments
|
}
|
|
/**
|
* Extracts a series of segments with the appropriate
|
* modes from a string
|
*
|
* @param {String} dataStr Input string
|
* @return {Array} Array of object with segments data
|
*/
|
function getSegmentsFromString (dataStr) {
|
const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr)
|
const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr)
|
let byteSegs
|
let kanjiSegs
|
|
if (Utils.isKanjiModeEnabled()) {
|
byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr)
|
kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr)
|
} else {
|
byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr)
|
kanjiSegs = []
|
}
|
|
const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs)
|
|
return segs
|
.sort(function (s1, s2) {
|
return s1.index - s2.index
|
})
|
.map(function (obj) {
|
return {
|
data: obj.data,
|
mode: obj.mode,
|
length: obj.length
|
}
|
})
|
}
|
|
/**
|
* Returns how many bits are needed to encode a string of
|
* specified length with the specified mode
|
*
|
* @param {Number} length String length
|
* @param {Mode} mode Segment mode
|
* @return {Number} Bit length
|
*/
|
function getSegmentBitsLength (length, mode) {
|
switch (mode) {
|
case Mode.NUMERIC:
|
return NumericData.getBitsLength(length)
|
case Mode.ALPHANUMERIC:
|
return AlphanumericData.getBitsLength(length)
|
case Mode.KANJI:
|
return KanjiData.getBitsLength(length)
|
case Mode.BYTE:
|
return ByteData.getBitsLength(length)
|
}
|
}
|
|
/**
|
* Merges adjacent segments which have the same mode
|
*
|
* @param {Array} segs Array of object with segments data
|
* @return {Array} Array of object with segments data
|
*/
|
function mergeSegments (segs) {
|
return segs.reduce(function (acc, curr) {
|
const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null
|
if (prevSeg && prevSeg.mode === curr.mode) {
|
acc[acc.length - 1].data += curr.data
|
return acc
|
}
|
|
acc.push(curr)
|
return acc
|
}, [])
|
}
|
|
/**
|
* Generates a list of all possible nodes combination which
|
* will be used to build a segments graph.
|
*
|
* Nodes are divided by groups. Each group will contain a list of all the modes
|
* in which is possible to encode the given text.
|
*
|
* For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.
|
* The group for '12345' will contain then 3 objects, one for each
|
* possible encoding mode.
|
*
|
* Each node represents a possible segment.
|
*
|
* @param {Array} segs Array of object with segments data
|
* @return {Array} Array of object with segments data
|
*/
|
function buildNodes (segs) {
|
const nodes = []
|
for (let i = 0; i < segs.length; i++) {
|
const seg = segs[i]
|
|
switch (seg.mode) {
|
case Mode.NUMERIC:
|
nodes.push([seg,
|
{ data: seg.data, mode: Mode.ALPHANUMERIC, length: seg.length },
|
{ data: seg.data, mode: Mode.BYTE, length: seg.length }
|
])
|
break
|
case Mode.ALPHANUMERIC:
|
nodes.push([seg,
|
{ data: seg.data, mode: Mode.BYTE, length: seg.length }
|
])
|
break
|
case Mode.KANJI:
|
nodes.push([seg,
|
{ data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
|
])
|
break
|
case Mode.BYTE:
|
nodes.push([
|
{ data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
|
])
|
}
|
}
|
|
return nodes
|
}
|
|
/**
|
* Builds a graph from a list of nodes.
|
* All segments in each node group will be connected with all the segments of
|
* the next group and so on.
|
*
|
* At each connection will be assigned a weight depending on the
|
* segment's byte length.
|
*
|
* @param {Array} nodes Array of object with segments data
|
* @param {Number} version QR Code version
|
* @return {Object} Graph of all possible segments
|
*/
|
function buildGraph (nodes, version) {
|
const table = {}
|
const graph = { start: {} }
|
let prevNodeIds = ['start']
|
|
for (let i = 0; i < nodes.length; i++) {
|
const nodeGroup = nodes[i]
|
const currentNodeIds = []
|
|
for (let j = 0; j < nodeGroup.length; j++) {
|
const node = nodeGroup[j]
|
const key = '' + i + j
|
|
currentNodeIds.push(key)
|
table[key] = { node: node, lastCount: 0 }
|
graph[key] = {}
|
|
for (let n = 0; n < prevNodeIds.length; n++) {
|
const prevNodeId = prevNodeIds[n]
|
|
if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
|
graph[prevNodeId][key] =
|
getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) -
|
getSegmentBitsLength(table[prevNodeId].lastCount, node.mode)
|
|
table[prevNodeId].lastCount += node.length
|
} else {
|
if (table[prevNodeId]) table[prevNodeId].lastCount = node.length
|
|
graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) +
|
4 + Mode.getCharCountIndicator(node.mode, version) // switch cost
|
}
|
}
|
}
|
|
prevNodeIds = currentNodeIds
|
}
|
|
for (let n = 0; n < prevNodeIds.length; n++) {
|
graph[prevNodeIds[n]].end = 0
|
}
|
|
return { map: graph, table: table }
|
}
|
|
/**
|
* Builds a segment from a specified data and mode.
|
* If a mode is not specified, the more suitable will be used.
|
*
|
* @param {String} data Input data
|
* @param {Mode | String} modesHint Data mode
|
* @return {Segment} Segment
|
*/
|
function buildSingleSegment (data, modesHint) {
|
let mode
|
const bestMode = Mode.getBestModeForData(data)
|
|
mode = Mode.from(modesHint, bestMode)
|
|
// Make sure data can be encoded
|
if (mode !== Mode.BYTE && mode.bit < bestMode.bit) {
|
throw new Error('"' + data + '"' +
|
' cannot be encoded with mode ' + Mode.toString(mode) +
|
'.\n Suggested mode is: ' + Mode.toString(bestMode))
|
}
|
|
// Use Mode.BYTE if Kanji support is disabled
|
if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) {
|
mode = Mode.BYTE
|
}
|
|
switch (mode) {
|
case Mode.NUMERIC:
|
return new NumericData(data)
|
|
case Mode.ALPHANUMERIC:
|
return new AlphanumericData(data)
|
|
case Mode.KANJI:
|
return new KanjiData(data)
|
|
case Mode.BYTE:
|
return new ByteData(data)
|
}
|
}
|
|
/**
|
* Builds a list of segments from an array.
|
* Array can contain Strings or Objects with segment's info.
|
*
|
* For each item which is a string, will be generated a segment with the given
|
* string and the more appropriate encoding mode.
|
*
|
* For each item which is an object, will be generated a segment with the given
|
* data and mode.
|
* Objects must contain at least the property "data".
|
* If property "mode" is not present, the more suitable mode will be used.
|
*
|
* @param {Array} array Array of objects with segments data
|
* @return {Array} Array of Segments
|
*/
|
exports.fromArray = function fromArray (array) {
|
return array.reduce(function (acc, seg) {
|
if (typeof seg === 'string') {
|
acc.push(buildSingleSegment(seg, null))
|
} else if (seg.data) {
|
acc.push(buildSingleSegment(seg.data, seg.mode))
|
}
|
|
return acc
|
}, [])
|
}
|
|
/**
|
* Builds an optimized sequence of segments from a string,
|
* which will produce the shortest possible bitstream.
|
*
|
* @param {String} data Input string
|
* @param {Number} version QR Code version
|
* @return {Array} Array of segments
|
*/
|
exports.fromString = function fromString (data, version) {
|
const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled())
|
|
const nodes = buildNodes(segs)
|
const graph = buildGraph(nodes, version)
|
const path = dijkstra.find_path(graph.map, 'start', 'end')
|
|
const optimizedSegs = []
|
for (let i = 1; i < path.length - 1; i++) {
|
optimizedSegs.push(graph.table[path[i]].node)
|
}
|
|
return exports.fromArray(mergeSegments(optimizedSegs))
|
}
|
|
/**
|
* Splits a string in various segments with the modes which
|
* best represent their content.
|
* The produced segments are far from being optimized.
|
* The output of this function is only used to estimate a QR Code version
|
* which may contain the data.
|
*
|
* @param {string} data Input string
|
* @return {Array} Array of segments
|
*/
|
exports.rawSplit = function rawSplit (data) {
|
return exports.fromArray(
|
getSegmentsFromString(data, Utils.isKanjiModeEnabled())
|
)
|
}
|
