ag-psd 32.0.0 → 34.0.0

package/src/text.ts

@@ -1,4 +1,4 @@
-import type { TextStyle, LayerTextData, ParagraphStyle, Font, AntiAlias, TextGridInfo, Justification, Color, TextPath } from './psd';
+import type { TextStyle, LayerTextData, ParagraphStyle, Font, AntiAlias, TextGridInfo, Justification, Color, TextPath, TextStyleRun } from './psd';
 import { clamp } from './helpers';
 
 interface Adjustments {
@@ -274,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
@@ -360,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);
@@ -578,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();
 		}
 	}
@@ -622,6 +633,81 @@ export function decodeEngineData(engineData: EngineData) {
 	return result;
 }
 
+// type tool info from Photoshop 5.0 and 5.5 ('tySh')
+export interface LegacyTextData {
+	transform: number[];
+	faces: { mark: number; name: string; familyName: string; styleName: string; script: number; }[];
+	styles: {
+		mark: number; faceMark: number; size: number; tracking: number; kerning: number; leading: number;
+		baselineShift: number; autoKerning: boolean;
+	}[];
+	lines: { orientation: number; alignment: number; chars: { code: number; style: number; }[]; }[];
+	color: Color;
+	antiAlias: boolean;
+}
+
+const fixed = (value: number) => value / 0x10000; // 16.16 fixed point value
+
+export function decodeLegacyTextData(data: LegacyTextData): LayerTextData {
+	const styleRuns: { length: number; mark: number; }[] = [];
+	let text = '';
+
+	for (const line of data.lines) {
+		for (const { code, style } of line.chars) {
+			text += String.fromCharCode(code);
+			const last = styleRuns[styleRuns.length - 1];
+
+			if (last && last.mark === style) {
+				last.length++;
+			} else {
+				styleRuns.push({ length: 1, mark: style });
+			}
+		}
+	}
+
+	// remove one trailing new line (Photoshop always appends it)
+	if (text.endsWith('\r')) {
+		text = text.slice(0, -1);
+		if (--styleRuns[styleRuns.length - 1].length === 0) styleRuns.pop();
+	}
+
+	const runs: TextStyleRun[] = styleRuns.map(({ length, mark }) => {
+		const s = data.styles.find(s => s.mark === mark) ?? data.styles[0];
+		const face = s && (data.faces.find(f => f.mark === s.faceMark) ?? data.faces[0]);
+		const style: TextStyle = {};
+
+		if (face) style.font = { name: face.name, script: face.script };
+
+		if (s) {
+			style.fontSize = fixed(s.size);
+			style.autoLeading = s.leading === 0;
+			if (s.leading) style.leading = fixed(s.leading);
+			style.tracking = Math.round(fixed(s.tracking) * 1000); // stored in ems
+			style.autoKerning = s.autoKerning;
+			style.kerning = Math.round(fixed(s.kerning) * 1000); // stored in ems
+			style.baselineShift = fixed(s.baselineShift);
+		}
+
+		style.fillColor = data.color;
+		return { length, style };
+	});
+
+	const result: LayerTextData = {
+		text: text.replace(/\r/g, '\n'),
+		transform: data.transform,
+		antiAlias: data.antiAlias ? 'smooth' : 'none',
+		orientation: data.lines[0]?.orientation === 1 ? 'vertical' : 'horizontal',
+		paragraphStyle: { justification: justification[data.lines[0]?.alignment ?? 0] ?? 'left' },
+		style: {},
+		styleRuns: runs,
+	};
+
+	deduplicateValues(result.style!, result.styleRuns!, styleKeys);
+	if (!result.styleRuns!.length) delete result.styleRuns;
+
+	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 {
@@ -671,14 +757,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: {

package/src/utf8.ts

@@ -113,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) {