ag-psd 31.0.3 → 33.0.0

package/src/text.ts

@@ -1,4 +1,5 @@
 import type { TextStyle, LayerTextData, ParagraphStyle, Font, AntiAlias, TextGridInfo, Justification, Color, TextPath } from './psd';
+import { clamp } from './helpers';
 
 interface Adjustments {
 	Axis: number[];
@@ -273,7 +274,16 @@ const styleKeys: (keyof TextStyle)[] = [
 	'kashida', 'diacriticPos',
 ];
 
-const antialias: AntiAlias[] = ['none', 'crisp', 'strong', 'smooth', 'sharp'];
+const antialias: (AntiAlias | undefined)[] = [
+	'none', // 0
+	'crisp', // 1
+	'strong', // 2
+	'smooth', // 3
+	'sharp', // 4
+	undefined, // 5 - unknown
+	'platformLCD', // 6
+	'platform', // 7
+];
 const justification: Justification[] = [
 	'left', // 0
 	'right', // 1
@@ -300,13 +310,43 @@ function decodeColor(color: TypeValues): Color {
 	}
 }
 
+// h, s, b in 0..1 range, returns r, g, b in 0..1 range
+function hsbToRgb(h: number, s: number, v: number): [number, number, number] {
+	h = clamp(h || 0, 0, 1);
+	s = clamp(s || 0, 0, 1);
+	v = clamp(v || 0, 0, 1);
+
+	const h6 = (h * 6) % 6;
+	const i = Math.floor(h6);
+	const f = h6 - i;
+	const p = v * (1 - s);
+	const q = v * (1 - s * f);
+	const t = v * (1 - s * (1 - f));
+
+	switch (i) {
+		case 0: return [v, t, p];
+		case 1: return [q, v, p];
+		case 2: return [p, v, t];
+		case 3: return [p, q, v];
+		case 4: return [t, p, v];
+		default: return [v, p, q];
+	}
+}
+
 function encodeColor(color: Color | undefined): TypeValues {
 	if (!color) {
 		return { Type: 1, Values: [0, 0, 0, 0] };
 	} else if ('r' in color) {
 		return { Type: 1, Values: ['a' in color ? color.a / 255 : 1, color.r / 255, color.g / 255, color.b / 255] };
+	} else if ('fr' in color) {
+		return { Type: 1, Values: [1, clamp(color.fr || 0, 0, 1), clamp(color.fg || 0, 0, 1), clamp(color.fb || 0, 0, 1)] };
+	} else if ('h' in color) {
+		const [r, g, b] = hsbToRgb(color.h, color.s, color.b);
+		return { Type: 1, Values: [1, r, g, b] };
 	} else if ('c' in color) {
 		return { Type: 2, Values: [1, color.c / 255, color.m / 255, color.y / 255, color.k / 255] };
+	} else if ('l' in color) {
+		throw new Error('LAB colors are not supported in text layers, use RGB, CMYK or grayscale color instead');
 	} else if ('k' in color) {
 		return { Type: 0, Values: [1, color.k / 255] };
 	} else {
@@ -329,8 +369,9 @@ function objectsEqual(a: any, b: any) {
 }
 
 function findOrAddFont(fonts: Font[], font: Font) {
+	// Photoshop writes separate entries for the same font with different synthetic (faux bold/italic) styles
 	for (let i = 0; i < fonts.length; i++) {
-		if (fonts[i].name === font.name) return i;
+		if (fonts[i].name === font.name && (fonts[i].synthetic || 0) === (font.synthetic || 0)) return i;
 	}
 
 	fonts.push(font);
@@ -346,9 +387,10 @@ function decodeObject(obj: any, keys: string[], fonts: Font[]) {
 		if (obj[Key] === undefined) continue;
 
 		if (key === 'justification') {
-			result[key] = justification[obj[Key]];
+			result[key] = justification[obj[Key]] ?? 'left';
 		} else if (key === 'font') {
-			result[key] = fonts[obj[Key]];
+			const font = fonts[obj[Key]];
+			if (font) result[key] = font; // invalid font index, leave the font unset so it falls back to default
 		} else if (key === 'fillColor' || key === 'strokeColor') {
 			result[key] = decodeColor(obj[Key]);
 		} else {
@@ -368,7 +410,7 @@ function encodeObject(obj: any, keys: string[], fonts: Font[]) {
 		if (obj[key] === undefined) continue;
 
 		if (key === 'justification') {
-			result[Key] = justification.indexOf(obj[key] ?? 'left');
+			result[Key] = Math.max(0, justification.indexOf(obj[key] ?? 'left')); // default to 'left' for unknown values
 		} else if (key === 'font') {
 			result[Key] = findOrAddFont(fonts, obj[key]);
 		} else if (key === 'fillColor' || key === 'strokeColor') {
@@ -443,6 +485,39 @@ function deduplicateValues<T>(base: T, runs: { style: T; }[], keys: (keyof T)[])
 	}
 }
 
+function isDefaultGridColor(color: Color | undefined) {
+	// Photoshop writes default grid colors as blue with 0 alpha, ignore alpha when comparing
+	return !!color && 'r' in color && color.r === 0 && color.g === 0 && color.b === 255;
+}
+
+function decodeGridColor(color: TypeValues | undefined, defaultColor: Color): Color {
+	try {
+		return color ? decodeColor(color) : defaultColor;
+	} catch {
+		return defaultColor; // don't fail whole text layer because of invalid grid color
+	}
+}
+
+function decodeGridInfo(grid: EngineData['EngineDict']['GridInfo'] | undefined): TextGridInfo | undefined {
+	if (!grid || typeof grid !== 'object') return undefined;
+
+	const result: TextGridInfo = {
+		isOn: !!grid.GridIsOn,
+		show: !!grid.ShowGrid,
+		size: grid.GridSize ?? defaultGridInfo.size,
+		leading: grid.GridLeading ?? defaultGridInfo.leading,
+		color: decodeGridColor(grid.GridColor, defaultGridInfo.color!),
+		leadingFillColor: decodeGridColor(grid.GridLeadingFillColor, defaultGridInfo.leadingFillColor!),
+		alignLineHeightToGridFlags: !!grid.AlignLineHeightToGridFlags,
+	};
+
+	const isDefault = !result.isOn && !result.show && result.size === defaultGridInfo.size &&
+		result.leading === defaultGridInfo.leading && !result.alignLineHeightToGridFlags &&
+		isDefaultGridColor(result.color) && isDefaultGridColor(result.leadingFillColor);
+
+	return isDefault ? undefined : result;
+}
+
 export function decodeEngineData(engineData: EngineData) {
 	// console.log('engineData', require('util').inspect(engineData, false, 99, true));
 	const engineDict = engineData.EngineDict;
@@ -458,9 +533,11 @@ export function decodeEngineData(engineData: EngineData) {
 	let text = engineDict.Editor.Text.replace(/\r/g, '\n');
 	let removedCharacters = 0;
 
-	while (/\n$/.test(text)) {
+	// Photoshop always appends exactly one trailing \r (and encoder adds one back), any additional
+	// trailing new lines are empty paragraphs that are part of the text
+	if (/\n$/.test(text)) {
 		text = text.substring(0, text.length - 1);
-		removedCharacters++;
+		removedCharacters = 1;
 	}
 
 	const result: LayerTextData = {
@@ -484,6 +561,11 @@ export function decodeEngineData(engineData: EngineData) {
 		if (photoshop.BoxBounds) result.boxBounds = photoshop.BoxBounds;
 	}
 
+	// grid info (only included when it differs from defaults, to avoid noise in common case)
+
+	const gridInfo = decodeGridInfo(engineDict.GridInfo);
+	if (gridInfo) result.gridInfo = gridInfo;
+
 	// paragraph style
 
 	// const theNormalParagraphSheet = resourceDict.TheNormalParagraphSheet;
@@ -506,7 +588,8 @@ export function decodeEngineData(engineData: EngineData) {
 	}
 
 	for (let counter = removedCharacters; result.paragraphStyleRuns.length && counter > 0; counter--) {
-		if (--result.paragraphStyleRuns[result.paragraphStyleRuns.length - 1].length === 0) {
+		// keep 0 length run if it's for empty last paragraph, otherwise we lose its style
+		if (--result.paragraphStyleRuns[result.paragraphStyleRuns.length - 1].length === 0 && result.paragraphStyleRuns.length === 1) {
 			result.paragraphStyleRuns.pop();
 		}
 	}
@@ -522,13 +605,18 @@ export function decodeEngineData(engineData: EngineData) {
 	// const styleSheetData = styleSheetSet[theNormalStyleSheet].StyleSheetData;
 	const styleRun = engineDict.StyleRun;
 
+	// style runs without a font use the font of the normal style sheet
+	const normalStyleSheet = resourceDict.StyleSheetSet?.[resourceDict.TheNormalStyleSheet ?? 0]?.StyleSheetData;
+	const normalFontIndex = normalStyleSheet?.Font;
+	const normalFont = (normalFontIndex !== undefined ? fonts[normalFontIndex] : undefined) ?? fonts[0];
+
 	result.style = {}; // decodeStyle(styleSheetData, fonts);
 	result.styleRuns = [];
 
 	for (let i = 0; i < styleRun.RunArray.length; i++) {
 		const length = styleRun.RunLengthArray[i];
 		const style = decodeStyle(styleRun.RunArray[i].StyleSheet.StyleSheetData, fonts);
-		if (!style.font) style.font = fonts[0];
+		if (!style.font && normalFont) style.font = normalFont;
 		result.styleRuns.push({ length, style });
 	}
 
@@ -545,8 +633,38 @@ export function decodeEngineData(engineData: EngineData) {
 	return result;
 }
 
+// Adjusts run lengths (specified in terms of the original text) for characters removed from the text
+// (\r characters of \r\n pairs that are collapsed into single \r)
+function adjustRunLengths<T extends { length: number; }>(runs: T[] | undefined, removed: number[]): T[] | undefined {
+	if (!runs || !removed.length) return runs;
+
+	let start = 0;
+	let removedIndex = 0;
+
+	return runs.map(run => {
+		const length = Math.max(0, run.length || 0);
+		const end = start + length;
+		let count = 0;
+
+		while (removedIndex < removed.length && removed[removedIndex] < end) {
+			if (removed[removedIndex] >= start) count++;
+			removedIndex++;
+		}
+
+		start = end;
+		return { ...run, length: length - count };
+	});
+}
+
 export function encodeEngineData(data: LayerTextData) {
-	const text = `${(data.text || '').replace(/\r?\n/g, '\r')}\r`;
+	const sourceText = data.text || '';
+	const removedIndices: number[] = []; // indices of \r characters removed from \r\n pairs
+
+	for (let i = 0; i < sourceText.length - 1; i++) {
+		if (sourceText.charCodeAt(i) === 13 && sourceText.charCodeAt(i + 1) === 10) removedIndices.push(i);
+	}
+
+	const text = `${sourceText.replace(/\r?\n/g, '\r')}\r`;
 
 	const fonts: Font[] = [
 		{ name: 'AdobeInvisFont', script: 0, type: 0, synthetic: 0 },
@@ -555,7 +673,7 @@ export function encodeEngineData(data: LayerTextData) {
 	const defFont = data.style?.font || data.styleRuns?.find(s => s.style.font)?.style.font || defaultFont;
 	const paragraphRunArray: ParagraphRun[] = [];
 	const paragraphRunLengthArray: number[] = [];
-	const paragraphRuns = data.paragraphStyleRuns;
+	const paragraphRuns = adjustRunLengths(data.paragraphStyleRuns, removedIndices);
 
 	if (paragraphRuns && paragraphRuns.length) {
 		let leftLength = text.length;
@@ -564,14 +682,14 @@ export function encodeEngineData(data: LayerTextData) {
 			let runLength = Math.min(run.length, leftLength);
 			leftLength -= runLength;
 
-			if (!runLength) continue; // ignore 0 size runs
-
-			// extend last run if it's only for trailing \r
+			// extend last run if it's only for trailing \r (last run has 0 length if it's for empty last paragraph)
 			if (leftLength === 1 && run === paragraphRuns[paragraphRuns.length - 1]) {
 				runLength++;
 				leftLength--;
 			}
 
+			if (!runLength) continue; // ignore 0 size runs
+
 			paragraphRunLengthArray.push(runLength);
 			paragraphRunArray.push({
 				ParagraphSheet: {
@@ -609,7 +727,9 @@ export function encodeEngineData(data: LayerTextData) {
 	}
 
 	const styleSheetData = encodeStyle({ ...defaultStyle, font: defFont }, fonts);
-	const styleRuns = data.styleRuns || [{ length: text.length, style: data.style || {} }];
+	const styleRuns = data.styleRuns?.length ?
+		adjustRunLengths(data.styleRuns, removedIndices)! :
+		[{ length: text.length, style: data.style || {} }];
 	const styleRunArray: StyleRun[] = [];
 	const styleRunLengthArray: number[] = [];
 
@@ -642,7 +762,7 @@ export function encodeEngineData(data: LayerTextData) {
 	}
 
 	// add extra run to the end if existing ones didn't fill it up
-	if (leftLength && styleRuns.length) {
+	if (leftLength) {
 		styleRunLengthArray.push(leftLength);
 		styleRunArray.push({
 			StyleSheet: {
@@ -657,6 +777,7 @@ export function encodeEngineData(data: LayerTextData) {
 	}
 
 	const gridInfo = { ...defaultGridInfo, ...data.gridInfo };
+	const antiAliasIndex = antialias.indexOf(data.antiAlias ?? 'sharp');
 	const WritingDirection = data.orientation === 'vertical' ? 2 : 0;
 	const Procession = data.orientation === 'vertical' ? 1 : 0;
 	const ShapeType = data.shapeType === 'box' ? 1 : 0;
@@ -753,10 +874,10 @@ export function encodeEngineData(data: LayerTextData) {
 				GridSize: gridInfo.size ?? 18,
 				GridLeading: gridInfo.leading ?? 22,
 				GridColor: encodeColor(gridInfo.color),
-				GridLeadingFillColor: encodeColor(gridInfo.color),
+				GridLeadingFillColor: encodeColor(gridInfo.leadingFillColor),
 				AlignLineHeightToGridFlags: !!gridInfo.alignLineHeightToGridFlags,
 			},
-			AntiAlias: antialias.indexOf(data.antiAlias ?? 'sharp'),
+			AntiAlias: antiAliasIndex === -1 ? antialias.indexOf('sharp') : antiAliasIndex,
 			UseFractionalGlyphWidths: data.useFractionalGlyphWidths ?? true,
 			Rendered: {
 				Version: 1,

package/src/utf8.ts

@@ -10,36 +10,48 @@ function charLengthInBytes(code: number): number {
 	}
 }
 
-// Reads a scalar value at index `i`, replacing unpaired surrogates with U+FFFD,
+// Returns scalar value at index `i` (combining surrogate pairs), replacing unpaired surrogates with U+FFFD,
 // matching how TextEncoder converts a string to a sequence of Unicode scalar values.
-function codePointAt(value: string, i: number): { code: number; size: number } {
+// Values above 0xffff always take 2 UTF-16 code units.
+function codePointAt(value: string, i: number): number {
 	const code = value.charCodeAt(i);
 
+	if (code < 0xd800 || code > 0xdfff) return code;
+
 	// high surrogate
-	if (code >= 0xd800 && code <= 0xdbff && (i + 1) < value.length) {
+	if (code <= 0xdbff && (i + 1) < value.length) {
 		const extra = value.charCodeAt(i + 1);
 
 		// low surrogate
 		if (extra >= 0xdc00 && extra <= 0xdfff) {
-			return { code: ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000, size: 2 };
+			return ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
 		}
 	}
 
 	// unpaired surrogate (lone high or lone low)
-	if (code >= 0xd800 && code <= 0xdfff) {
-		return { code: 0xfffd, size: 1 };
-	}
-
-	return { code, size: 1 };
+	return 0xfffd;
 }
 
 export function stringLengthInBytes(value: string): number {
 	let result = 0;
 
-	for (let i = 0; i < value.length;) {
-		const { code, size } = codePointAt(value, i);
-		result += charLengthInBytes(code);
-		i += size;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+
+		if (code < 0x80) {
+			result += 1;
+		} else if (code < 0x800) {
+			result += 2;
+		} else {
+			const scalar = codePointAt(value, i);
+
+			if (scalar > 0xffff) {
+				result += 4;
+				i++;
+			} else {
+				result += 3;
+			}
+		}
 	}
 
 	return result;
@@ -73,10 +85,16 @@ function writeCharacter(buffer: Uint8Array | Buffer, offset: number, code: numbe
 }
 
 export function encodeStringTo(buffer: Uint8Array | Buffer, offset: number, value: string): number {
-	for (let i = 0; i < value.length;) {
-		const { code, size } = codePointAt(value, i);
-		offset += writeCharacter(buffer, offset, code);
-		i += size;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+
+		if (code < 0x80) {
+			buffer[offset++] = code;
+		} else {
+			const scalar = codePointAt(value, i);
+			if (scalar > 0xffff) i++;
+			offset += writeCharacter(buffer, offset, scalar);
+		}
 	}
 
 	return offset;
@@ -95,10 +113,6 @@ export function encodeString(value: string): Uint8Array {
 // UTF-8 decoder implementing the WHATWG Encoding Standard's non-fatal error handling,
 // so malformed byte sequences are replaced with U+FFFD instead of throwing, matching TextDecoder.
 export function decodeString(value: Uint8Array): string {
-	if (value.byteLength > 1000 && typeof TextDecoder !== 'undefined') {
-		return (new TextDecoder()).decode(value);
-	}
-
 	const result: string[] = [];
 
 	function pushCodePoint(code: number) {