File: /var/www/vhost/disk-apps/pwa.sports-crowd.com/node_modules/@prettier/plugin-xml/dist/printer.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const doc_1 = require("prettier/doc");
const embed_1 = __importDefault(require("./embed"));
const { fill, group, hardline, indent, join, line, literalline, softline } = doc_1.builders;
const ignoreStartComment = "<!-- prettier-ignore-start -->";
const ignoreEndComment = "<!-- prettier-ignore-end -->";
function hasIgnoreRanges(comments) {
if (!comments || comments.length === 0) {
return false;
}
comments.sort((left, right) => left.startOffset - right.startOffset);
let startFound = false;
for (let idx = 0; idx < comments.length; idx += 1) {
if (comments[idx].image === ignoreStartComment) {
startFound = true;
}
else if (startFound && comments[idx].image === ignoreEndComment) {
return true;
}
}
return false;
}
function isWhitespaceIgnorable(node) {
const { CData, Comment, reference } = node.children;
return !CData && !reference && !hasIgnoreRanges(Comment);
}
function printIToken(path) {
const node = path.getValue();
return {
offset: node.startOffset,
startLine: node.startLine,
endLine: node.endLine,
printed: node.image
};
}
function replaceNewlinesWithLiteralLines(content) {
return content
.split(/(\n)/g)
.map((value, idx) => (idx % 2 === 0 ? value : literalline));
}
const printer = {
embed: embed_1.default,
print(path, opts, print) {
const node = path.getValue();
switch (node.name) {
case "attribute": {
const { Name, EQUALS, STRING } = node.children;
return [Name[0].image, EQUALS[0].image, STRING[0].image];
}
case "chardata": {
const { SEA_WS, TEXT } = node.children;
const [{ image }] = SEA_WS || TEXT;
return image
.split(/(\n)/g)
.map((value, index) => (index % 2 === 0 ? value : literalline));
}
case "content": {
const nodePath = path;
let fragments = nodePath.call((childrenPath) => {
let response = [];
const children = childrenPath.getValue();
if (children.CData) {
response = response.concat(childrenPath.map(printIToken, "CData"));
}
if (children.Comment) {
response = response.concat(childrenPath.map(printIToken, "Comment"));
}
if (children.chardata) {
response = response.concat(childrenPath.map((charDataPath) => ({
offset: charDataPath.getValue().location.startOffset,
printed: print(charDataPath)
}), "chardata"));
}
if (children.element) {
response = response.concat(childrenPath.map((elementPath) => ({
offset: elementPath.getValue().location.startOffset,
printed: print(elementPath)
}), "element"));
}
if (children.PROCESSING_INSTRUCTION) {
response = response.concat(childrenPath.map(printIToken, "PROCESSING_INSTRUCTION"));
}
if (children.reference) {
response = response.concat(childrenPath.map((referencePath) => {
const referenceNode = referencePath.getValue();
return {
offset: referenceNode.location.startOffset,
printed: (referenceNode.children.CharRef ||
referenceNode.children.EntityRef)[0].image
};
}, "reference"));
}
return response;
}, "children");
const { Comment } = node.children;
if (hasIgnoreRanges(Comment)) {
Comment.sort((left, right) => left.startOffset - right.startOffset);
const ignoreRanges = [];
let ignoreStart = null;
// Build up a list of ignored ranges from the original text based on the
// special prettier-ignore-* comments
Comment.forEach((comment) => {
if (comment.image === ignoreStartComment) {
ignoreStart = comment;
}
else if (ignoreStart && comment.image === ignoreEndComment) {
ignoreRanges.push({
start: ignoreStart.startOffset,
end: comment.endOffset
});
ignoreStart = null;
}
});
// Filter the printed children to only include the ones that are outside
// of each of the ignored ranges
fragments = fragments.filter((fragment) => ignoreRanges.every(({ start, end }) => fragment.offset < start || fragment.offset > end));
// Push each of the ignored ranges into the child list as its own element
// so that the original content is still included
ignoreRanges.forEach(({ start, end }) => {
const content = opts.originalText.slice(start, end + 1);
fragments.push({
offset: start,
printed: replaceNewlinesWithLiteralLines(content)
});
});
}
fragments.sort((left, right) => left.offset - right.offset);
return group(fragments.map(({ printed }) => printed));
}
case "docTypeDecl": {
const { DocType, Name, externalID, CLOSE } = node.children;
const parts = [DocType[0].image, " ", Name[0].image];
if (externalID) {
parts.push(" ", path.call(print, "children", "externalID", 0));
}
return group([...parts, CLOSE[0].image]);
}
case "document": {
const { docTypeDecl, element, misc, prolog } = node.children;
const fragments = [];
if (docTypeDecl) {
fragments.push({
offset: docTypeDecl[0].location.startOffset,
printed: path.call(print, "children", "docTypeDecl", 0)
});
}
if (prolog) {
fragments.push({
offset: prolog[0].location.startOffset,
printed: path.call(print, "children", "prolog", 0)
});
}
if (misc) {
misc.forEach((node) => {
if (node.children.PROCESSING_INSTRUCTION) {
fragments.push({
offset: node.location.startOffset,
printed: node.children.PROCESSING_INSTRUCTION[0].image
});
}
else if (node.children.Comment) {
fragments.push({
offset: node.location.startOffset,
printed: node.children.Comment[0].image
});
}
});
}
if (element) {
fragments.push({
offset: element[0].location.startOffset,
printed: path.call(print, "children", "element", 0)
});
}
fragments.sort((left, right) => left.offset - right.offset);
return [
join(hardline, fragments.map(({ printed }) => printed)),
hardline
];
}
case "element": {
const { OPEN, Name, attribute, START_CLOSE, content, SLASH_OPEN, END_NAME, END, SLASH_CLOSE } = node.children;
const parts = [OPEN[0].image, Name[0].image];
if (attribute) {
const separator = opts.singleAttributePerLine ? hardline : line;
parts.push(indent([
line,
join(separator, path.map(print, "children", "attribute"))
]));
}
// Determine the value that will go between the <, name, and attributes
// of an element and the /> of an element.
const space = opts.xmlSelfClosingSpace ? line : softline;
if (SLASH_CLOSE) {
return group([...parts, space, SLASH_CLOSE[0].image]);
}
if (Object.keys(content[0].children).length === 0) {
return group([...parts, space, "/>"]);
}
const openTag = group([
...parts,
opts.bracketSameLine ? "" : softline,
START_CLOSE[0].image
]);
const closeTag = group([
SLASH_OPEN[0].image,
END_NAME[0].image,
END[0].image
]);
if (opts.xmlWhitespaceSensitivity === "ignore" &&
isWhitespaceIgnorable(content[0])) {
const nodePath = path;
const fragments = nodePath.call((childrenPath) => {
const children = childrenPath.getValue();
let response = [];
if (children.Comment) {
response = response.concat(childrenPath.map(printIToken, "Comment"));
}
if (children.chardata) {
childrenPath.each((charDataPath) => {
const chardata = charDataPath.getValue();
if (!chardata.children.TEXT) {
return;
}
const content = chardata.children.TEXT[0].image.trim();
const printed = group(content.split(/(\n)/g).map((value) => {
if (value === "\n") {
return literalline;
}
return fill(value
.split(/\b( +)\b/g)
.map((segment, index) => index % 2 === 0 ? segment : line));
}));
const location = chardata.location;
response.push({
offset: location.startOffset,
startLine: location.startLine,
endLine: location.endLine,
printed
});
}, "chardata");
}
if (children.element) {
response = response.concat(childrenPath.map((elementPath) => {
const location = elementPath.getValue().location;
return {
offset: location.startOffset,
startLine: location.startLine,
endLine: location.endLine,
printed: print(elementPath)
};
}, "element"));
}
if (children.PROCESSING_INSTRUCTION) {
response = response.concat(childrenPath.map(printIToken, "PROCESSING_INSTRUCTION"));
}
return response;
}, "children", "content", 0, "children");
fragments.sort((left, right) => left.offset - right.offset);
// If the only content of this tag is chardata, then use a softline so
// that we won't necessarily break (to allow <foo>bar</foo>).
if (fragments.length === 1 &&
(content[0].children.chardata || []).filter((chardata) => chardata.children.TEXT).length === 1) {
return group([
openTag,
indent([softline, fragments[0].printed]),
softline,
closeTag
]);
}
if (fragments.length === 0) {
return group([...parts, space, "/>"]);
}
const docs = [];
let lastLine = fragments[0].startLine;
fragments.forEach((node) => {
if (node.startLine - lastLine >= 2) {
docs.push(hardline, hardline);
}
else {
docs.push(hardline);
}
docs.push(node.printed);
lastLine = node.endLine;
});
return group([openTag, indent(docs), hardline, closeTag]);
}
return group([
openTag,
indent(path.call(print, "children", "content", 0)),
closeTag
]);
}
case "externalID": {
const { Public, PubIDLiteral, System, SystemLiteral } = node.children;
if (System) {
return group([
System[0].image,
indent([line, SystemLiteral[0].image])
]);
}
return group([
group([Public[0].image, indent([line, PubIDLiteral[0].image])]),
indent([line, SystemLiteral[0].image])
]);
}
case "prolog": {
const { XMLDeclOpen, attribute, SPECIAL_CLOSE } = node.children;
const parts = [XMLDeclOpen[0].image];
if (attribute) {
parts.push(indent([
softline,
join(line, path.map(print, "children", "attribute"))
]));
}
const space = opts.xmlSelfClosingSpace ? line : softline;
return group([...parts, space, SPECIAL_CLOSE[0].image]);
}
}
}
};
exports.default = printer;