Karl O'Keeffe
5cda955efc
* Add new fill primitive and use it to wrap text in JSX This adds a new `fill` primitive that can be used to fill lines with as much code as possible before moving to a new line with the same indentation. It is used here layout JSX children. This gives us nicer wrapping for JSX elements containings lots of text interspersed with tags. * Quick fix for jsx whitespace regressions * Fix a couple more bugs * Tidy up the `fill` algorithm Attempt to make the algorithm a little more regular, and improve the naming of variables to make it a little easier to understand (I hope!). * Small tidy up of JSX whitespace declarations * Remove unnecessary code It turns out that `children` is only used in the case when the element is printed on a single line, in which case all the types of JSX whitespaces behave the same, so we don't need to special case leading/trailing/solitary whitespace. * A little more tidy up based on PR feedback * Fix up tests after rebasing * Make it explicit that we keep multiple consecutive spaces * Add an explanatory comment * Fix broken snapshot in master * Ignore existing commands when deciding whether content will fit when using fill * Fix a bug where children would get incorrectly filled onto a line * Tidy up JSX whitespace names
120 lines
2.2 KiB
JavaScript
120 lines
2.2 KiB
JavaScript
"use strict";
|
|
|
|
function assertDoc(val) {
|
|
if (
|
|
!(typeof val === "string" || (val != null && typeof val.type === "string"))
|
|
) {
|
|
throw new Error(
|
|
"Value " + JSON.stringify(val) + " is not a valid document"
|
|
);
|
|
}
|
|
}
|
|
|
|
function concat(parts) {
|
|
parts.forEach(assertDoc);
|
|
|
|
// We cannot do this until we change `printJSXElement` to not
|
|
// access the internals of a document directly.
|
|
// if(parts.length === 1) {
|
|
// // If it's a single document, no need to concat it.
|
|
// return parts[0];
|
|
// }
|
|
return { type: "concat", parts };
|
|
}
|
|
|
|
function indent(contents) {
|
|
assertDoc(contents);
|
|
|
|
return { type: "indent", contents };
|
|
}
|
|
|
|
function align(n, contents) {
|
|
assertDoc(contents);
|
|
|
|
return { type: "align", contents, n };
|
|
}
|
|
|
|
function group(contents, opts) {
|
|
opts = opts || {};
|
|
|
|
assertDoc(contents);
|
|
|
|
return {
|
|
type: "group",
|
|
contents: contents,
|
|
break: !!opts.shouldBreak,
|
|
expandedStates: opts.expandedStates
|
|
};
|
|
}
|
|
|
|
function conditionalGroup(states, opts) {
|
|
return group(
|
|
states[0],
|
|
Object.assign(opts || {}, { expandedStates: states })
|
|
);
|
|
}
|
|
|
|
function fill(parts) {
|
|
parts.forEach(assertDoc);
|
|
|
|
return { type: "fill", parts };
|
|
}
|
|
|
|
function ifBreak(breakContents, flatContents) {
|
|
if (breakContents) {
|
|
assertDoc(breakContents);
|
|
}
|
|
if (flatContents) {
|
|
assertDoc(flatContents);
|
|
}
|
|
|
|
return { type: "if-break", breakContents, flatContents };
|
|
}
|
|
|
|
function lineSuffix(contents) {
|
|
assertDoc(contents);
|
|
return { type: "line-suffix", contents };
|
|
}
|
|
|
|
const lineSuffixBoundary = { type: "line-suffix-boundary" };
|
|
const breakParent = { type: "break-parent" };
|
|
const line = { type: "line" };
|
|
const softline = { type: "line", soft: true };
|
|
const hardline = concat([{ type: "line", hard: true }, breakParent]);
|
|
const literalline = concat([
|
|
{ type: "line", hard: true, literal: true },
|
|
breakParent
|
|
]);
|
|
|
|
function join(sep, arr) {
|
|
var res = [];
|
|
|
|
for (var i = 0; i < arr.length; i++) {
|
|
if (i !== 0) {
|
|
res.push(sep);
|
|
}
|
|
|
|
res.push(arr[i]);
|
|
}
|
|
|
|
return concat(res);
|
|
}
|
|
|
|
module.exports = {
|
|
concat,
|
|
join,
|
|
line,
|
|
softline,
|
|
hardline,
|
|
literalline,
|
|
group,
|
|
conditionalGroup,
|
|
fill,
|
|
lineSuffix,
|
|
lineSuffixBoundary,
|
|
breakParent,
|
|
ifBreak,
|
|
indent,
|
|
align
|
|
};
|