forked from Blendman974/faceclaw
87 lines
3.1 KiB
TypeScript
87 lines
3.1 KiB
TypeScript
/**
|
|
* Word wrap for EvenHub text containers, after LVGL's lv_text_get_next_line
|
|
* as ported by @evenrealities/pretext's measureTextWrap, so soft breaks land
|
|
* where apps that measure with pretext expect them. The loop mirrors
|
|
* measureTextWrap's, including rescanning from the break point when it wraps
|
|
* at an earlier opportunity.
|
|
*
|
|
* One deliberate difference from pretext: pretext skips leading spaces at the
|
|
* start of every line, but stock keeps them at the start of the text and after
|
|
* a '\n'; only a soft-wrapped continuation line loses them. Apps indent with
|
|
* spaces to clear image containers placed beside their text: Iris Pro indents a
|
|
* line 11 spaces (44px) past a 40px glyph. Stripping that indent slid the text
|
|
* under the icon.
|
|
*/
|
|
|
|
/** Wrap opportunities: space, hyphen, and between CJK ideographs (pretext parity). */
|
|
export function isLvglBreakable(cp: number): boolean {
|
|
if (cp === 32 || cp === 45) return true;
|
|
return (cp >= 0x2e80 && cp <= 0x9fff) || (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0xac00 && cp <= 0xd7af);
|
|
}
|
|
|
|
/**
|
|
* Split text into display lines no wider than maxWidth.
|
|
* `advanceOf(cp, next)` is the kerned pixel advance of cp before next (0 at the end).
|
|
*/
|
|
export function wrapLvglText(text: string, maxWidth: number, advanceOf: (cp: number, next: number) => number): string[] {
|
|
if (!text) return [""];
|
|
const cps = Array.from(text).map((c) => c.codePointAt(0)!);
|
|
const lines: string[] = [];
|
|
let line: number[] = [];
|
|
let lineWidth = 0;
|
|
// The last break opportunity on this line, as an index into cps, and how
|
|
// many of `line`'s codepoints a wrap there keeps (a breaking space is dropped).
|
|
let lastBreak = -1;
|
|
let lastBreakKeep = 0;
|
|
// Whether `line` continues a soft-wrapped line, whose leading spaces are dropped.
|
|
let continuation = false;
|
|
|
|
const endLine = (keep: number[], next: number[], nextWidth: number) => {
|
|
lines.push(String.fromCodePoint(...keep));
|
|
line = next;
|
|
lineWidth = nextWidth;
|
|
lastBreak = -1;
|
|
continuation = true;
|
|
};
|
|
|
|
let i = 0;
|
|
while (i < cps.length) {
|
|
const cp = cps[i]!;
|
|
if (cp === 10) {
|
|
endLine(line, [], 0);
|
|
continuation = false;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (continuation && line.length === 0 && cp === 32) {
|
|
i++;
|
|
continue;
|
|
}
|
|
const adv = advanceOf(cp, cps[i + 1] ?? 0);
|
|
if (lineWidth + adv <= maxWidth) {
|
|
line.push(cp);
|
|
lineWidth += adv;
|
|
if (isLvglBreakable(cp)) {
|
|
lastBreak = i;
|
|
lastBreakKeep = cp === 32 ? line.length - 1 : line.length;
|
|
}
|
|
i++;
|
|
} else if (cp === 32) {
|
|
// The overflowing char is a space: break here and discard it.
|
|
endLine(line, [], 0);
|
|
i++;
|
|
} else if (lastBreak !== -1) {
|
|
// Wrap at the last break opportunity and rescan from just after it.
|
|
const restart = lastBreak + 1;
|
|
endLine(line.slice(0, lastBreakKeep), [], 0);
|
|
i = restart;
|
|
} else {
|
|
// No break opportunity: hard break before the overflowing char.
|
|
endLine(line, [cp], adv);
|
|
i++;
|
|
}
|
|
}
|
|
lines.push(String.fromCodePoint(...line));
|
|
return lines;
|
|
}
|