(function (global, factory) {
|
// eslint-disable-next-line no-unused-expressions
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports)
|
// eslint-disable-next-line no-undef
|
: typeof define === 'function' && define.amd ? define('jsonlint-printer', ['exports'], factory)
|
// eslint-disable-next-line no-undef
|
: (global = global || self, factory(global.jsonlintPrinter = {}))
|
}(this, function (exports) {
|
'use strict'
|
|
function noop () {}
|
|
function isIdentifierName (value) {
|
return /^[a-zA-Z$_][a-zA-Z0-9$_]*$/.test(value)
|
}
|
|
function concatenateTokens (tokens) {
|
var outputString = ''
|
var tokenCount = tokens.length
|
var tokenIndex
|
for (tokenIndex = 0; tokenIndex < tokenCount; ++tokenIndex) {
|
outputString += tokens[tokenIndex].raw
|
}
|
return outputString
|
}
|
|
function print (tokens, options) {
|
if (!(tokens && tokens.length)) {
|
throw new Error('JSON tokens missing.')
|
}
|
// Whitespace and comments are available only as raw token content.
|
if (!(tokens[0] && tokens[0].raw)) {
|
throw new Error('JSON tokens lack raw values.')
|
}
|
|
if (!options) {
|
// If no options, not even an empty object is passed, just concatenate
|
// the raw tokens with neither minification, nor pretty-printing.
|
return concatenateTokens(tokens)
|
}
|
|
var indentString = options.indent
|
if (typeof indentString === 'number') {
|
indentString = new Array(indentString + 1).join(' ')
|
}
|
// Setting the indent to an empty string enables pretty-printing too.
|
// It will just insert line breaks without any indentation.
|
var prettyPrint = indentString !== undefined
|
var pruneComments = options.pruneComments
|
var stripObjectKeys = options.stripObjectKeys
|
var enforceDoubleQuotes = options.enforceDoubleQuotes
|
var enforceSingleQuotes = options.enforceSingleQuotes
|
var trimTrailingCommas = options.trimTrailingCommas
|
|
var outputString = ''
|
var foundLineBreak, addedLineBreak, needsLineBreak
|
var addedSpace, needsSpace
|
var indentLevel = 0
|
var scopes = []
|
var scopeType
|
var isValue
|
var tokenCount = tokens.length
|
var tokenIndex, token, tokenType, tokenContent
|
|
function peekAtNextToken () {
|
var nextTokenIndex = tokenIndex
|
var nextToken
|
do {
|
nextToken = tokens[++nextTokenIndex]
|
} while (nextToken && (nextToken.type === 'whitespace' ||
|
nextToken.type === 'comment'))
|
return nextToken
|
}
|
|
var addIndent
|
if (prettyPrint && indentString) {
|
addIndent = function () {
|
for (var i = 0; i < indentLevel; ++i) {
|
outputString += indentString
|
}
|
}
|
} else {
|
addIndent = noop
|
}
|
|
var addLineBreak, addDelayedSpaceOrLineBreak
|
if (prettyPrint) {
|
addLineBreak = function () {
|
outputString += '\n'
|
}
|
|
addDelayedSpaceOrLineBreak = function () {
|
// A line break is more important than a space.
|
if (needsLineBreak) {
|
addLineBreak()
|
addIndent()
|
} else if (needsSpace) {
|
outputString += ' '
|
}
|
needsSpace = needsLineBreak = false
|
}
|
} else {
|
addLineBreak = addDelayedSpaceOrLineBreak = noop
|
}
|
|
var addStandaloneComment, tryAddingInlineComment
|
if (pruneComments) {
|
addStandaloneComment = tryAddingInlineComment = noop
|
} else {
|
if (prettyPrint) {
|
addStandaloneComment = function () {
|
// If a comment is not appended to the end of a line, it will start
|
// on a new line with the current indentation.
|
if (!addedLineBreak && tokenIndex > 0) {
|
addLineBreak()
|
addIndent()
|
}
|
outputString += tokenContent
|
foundLineBreak = false
|
addedLineBreak = false
|
// If a comment is not appended to the end of a line, it will take
|
// the whole line and has to end by a line break.
|
needsLineBreak = true
|
}
|
|
tryAddingInlineComment = function () {
|
// This function is called after printing a non-line-break character.
|
foundLineBreak = false
|
addedLineBreak = false
|
addedSpace = false
|
|
// Start with the character after the just processed one.
|
var tryTokenIndex = tokenIndex + 1
|
|
function skipWhitespace () {
|
var token = tokens[tryTokenIndex]
|
if (token && token.type === 'whitespace') {
|
foundLineBreak = token.raw.indexOf('\n') >= 0
|
token = tokens[++tryTokenIndex]
|
}
|
return token
|
}
|
|
var token = skipWhitespace()
|
// If line break followed the previous token, leave the comment
|
// to be handled by the next usual token processing.
|
if (!foundLineBreak && token && token.type === 'comment') {
|
if (needsLineBreak) {
|
// If the previous non-whitespace token was ended by a line
|
// break, retain it. Print the comment after the line break too.
|
if (!addedLineBreak) {
|
addLineBreak()
|
addIndent()
|
}
|
} else {
|
// If the previous non-whitespace token was not ended by a line
|
// break, ensure that the comment is separated from it.
|
if (!addedSpace) {
|
outputString += ' '
|
}
|
}
|
outputString += token.raw
|
// Set the current token to the just processed comment.
|
tokenIndex = tryTokenIndex++
|
// Check the whitespace after the comment to give a hint
|
// about the next whitespace to the further processing.
|
skipWhitespace()
|
if (foundLineBreak) {
|
needsSpace = false
|
needsLineBreak = true
|
} else {
|
needsSpace = true
|
needsLineBreak = false
|
}
|
}
|
}
|
} else {
|
// If all whitespace is omitted, convert single-line comments
|
// to multi-line ones, which include a comment-closing token.
|
addStandaloneComment = function () {
|
if (tokenContent[1] === '/') {
|
outputString += '/*'
|
outputString += tokenContent.substr(2, tokenContent.length - 2)
|
outputString += ' */'
|
} else {
|
outputString += tokenContent
|
}
|
}
|
|
tryAddingInlineComment = noop
|
}
|
}
|
|
function addLiteral () {
|
addDelayedSpaceOrLineBreak()
|
var tokenValue = token.value
|
if (stripObjectKeys && scopeType === '{' && !isValue &&
|
isIdentifierName(tokenValue)) {
|
outputString += tokenValue
|
} else if (typeof tokenValue === 'string') {
|
if (enforceDoubleQuotes && tokenContent[0] !== '"') {
|
outputString += JSON.stringify(tokenValue)
|
} else if (enforceSingleQuotes && tokenContent[0] !== '\'') {
|
outputString += '\'' + tokenValue.replace(/'/g, '\\\'') + '\''
|
} else {
|
outputString += tokenContent
|
}
|
} else {
|
outputString += tokenContent
|
}
|
tryAddingInlineComment()
|
}
|
|
function openScope () {
|
addDelayedSpaceOrLineBreak()
|
scopes.push(scopeType)
|
scopeType = tokenContent
|
isValue = scopeType === '['
|
outputString += tokenContent
|
tryAddingInlineComment()
|
++indentLevel
|
needsLineBreak = true
|
}
|
|
function closeScope () {
|
scopeType = scopes.pop()
|
addLineBreak()
|
--indentLevel
|
addIndent()
|
needsSpace = needsLineBreak = false
|
outputString += tokenContent
|
tryAddingInlineComment()
|
}
|
|
function addComma () {
|
if (trimTrailingCommas) {
|
var nextToken = peekAtNextToken()
|
if (nextToken && nextToken.type === 'symbol') {
|
return tryAddingInlineComment()
|
}
|
}
|
addDelayedSpaceOrLineBreak()
|
outputString += ','
|
tryAddingInlineComment()
|
addLineBreak()
|
addIndent()
|
addedLineBreak = true
|
needsLineBreak = false
|
isValue = scopeType === '['
|
}
|
|
function addColon () {
|
addDelayedSpaceOrLineBreak()
|
outputString += ':'
|
needsSpace = true
|
tryAddingInlineComment()
|
isValue = true
|
}
|
|
for (tokenIndex = 0; tokenIndex < tokenCount; ++tokenIndex) {
|
token = tokens[tokenIndex]
|
tokenType = token.type
|
tokenContent = token.raw
|
switch (tokenType) {
|
case 'literal':
|
addLiteral()
|
break
|
case 'comment':
|
addStandaloneComment()
|
break
|
case 'symbol':
|
switch (tokenContent) {
|
case '{':
|
case '[':
|
openScope()
|
break
|
case '}':
|
case ']':
|
closeScope()
|
break
|
case ',':
|
addComma()
|
break
|
case ':':
|
addColon()
|
}
|
break
|
default: // whitespace
|
foundLineBreak = tokenContent.indexOf('\n') >= 0
|
}
|
}
|
|
return outputString
|
}
|
|
exports.print = print
|
|
Object.defineProperty(exports, '__esModule', { value: true })
|
}))
|
