ag-psd 32.0.0 → 33.0.0

package/src/psdWriter.ts

@@ -1,20 +1,22 @@
 import { Psd, Layer, LayerAdditionalInfo, ColorMode, SectionDividerType, WriteOptions, Color, GlobalLayerMaskInfo, PixelData, LayerMaskData, Compression, ChannelID, PatternInfo } from './psd';
-import { hasAlpha, createCanvas, writeDataRLE, LayerChannelData, ChannelData, offsetForChannel, createImageData, fromBlendMode, clamp, LayerMaskFlags, MaskParams, ColorSpace, Bounds, largeAdditionalInfoKeys, RAW_IMAGE_DATA, writeDataZipWithoutPrediction, imageDataToCanvas, denormalizeLabAB } from './helpers';
-import { ExtendedWriteOptions, infoHandlers } from './additionalInfo';
+import { hasAlpha, createCanvas, writeDataRLE, LayerChannelData, ChannelData, offsetForChannel, createImageData, fromBlendMode, clamp, LayerMaskFlags, MaskParams, ColorSpace, Bounds, largeAdditionalInfoKeys, writeDataZipWithoutPrediction, imageDataToCanvas, denormalizeLabAB } from './helpers';
+import { ExtendedWriteOptions, infoHandlers, infoHandlersMap } from './additionalInfo';
 import { InternalImageResources, resourceHandlers } from './imageResources';
+import { getCompositeImageData, getLayerImageData, getLayerMaskImageData, getLayerRealMaskImageData } from './psdReader';
 
 export interface PsdWriter {
 	offset: number;
 	buffer: ArrayBuffer;
 	view: DataView;
 	tempBuffer: Uint8Array | undefined;
+	log(...args: any[]): void;
 }
 
 export function createWriter(size = 4096): PsdWriter {
 	const buffer = new ArrayBuffer(size);
 	const view = new DataView(buffer);
 	const offset = 0;
-	return { buffer, view, offset, tempBuffer: undefined };
+	return { buffer, view, offset, tempBuffer: undefined, log: console.log };
 }
 
 export function getWriterBuffer(writer: PsdWriter) {
@@ -241,6 +243,8 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 	if (bitsPerChannel !== 8)
 		throw new Error('bitsPerChannel other than 8 are not supported for writing');
 
+	if (options.log) writer.log = options.log;
+
 	const layers: Layer[] = [];
 	addChildren(layers, psd.children);
 	if (!layers.length) layers.push({});
@@ -250,6 +254,18 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 	const imageResources: InternalImageResources = { ...psd.imageResources };
 	const opt: ExtendedWriteOptions = { ...options, layerIds: new Set(), layerToId: new Map() };
 
+	// document is always written in RGB color mode, skip resources specific to original color mode
+	if (psd.colorMode !== undefined && psd.colorMode !== ColorMode.RGB) {
+		delete imageResources.iccProfile;
+		delete imageResources.indexedColorCount;
+		delete imageResources.transparencyIndex;
+		delete imageResources.alphaChannelDisplayInfo;
+		delete imageResources.colorHalftoneScreens;
+		delete imageResources.grayscaleHalftoneScreens;
+		delete imageResources.colorTransferFunctions;
+		delete imageResources.grayscaleTransferFunctions;
+	}
+
 	if (opt.generateThumbnail) {
 		imageResources.thumbnail = createThumbnail(psd);
 	}
@@ -260,6 +276,10 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 		imageData = psd.canvas.getContext('2d')!.getImageData(0, 0, psd.canvas.width, psd.canvas.height);
 	}
 
+	if (!imageData && psd.rawCompositeData) { // read with `useRawData` option
+		imageData = getCompositeImageData(psd);
+	}
+
 	if (imageData && (psd.width !== imageData.width || psd.height !== imageData.height))
 		throw new Error('Document canvas must have the same size as document');
 
@@ -277,16 +297,8 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 	writeUint16(writer, bitsPerChannel); // bits per channel
 	writeUint16(writer, ColorMode.RGB); // we only support saving RGB right now
 
-	// color mode data
-	writeSection(writer, 1, () => {
-		if (psd.palette) {
-			for (let i = 0; i < 256; i++) writeUint8(writer, psd.palette[i]?.r || 0);
-			for (let i = 0; i < 256; i++) writeUint8(writer, psd.palette[i]?.g || 0);
-			for (let i = 0; i < 256; i++) writeUint8(writer, psd.palette[i]?.b || 0);
-		}
-
-		// TODO: other data?
-	});
+	// color mode data (empty for RGB color mode)
+	writeUint32(writer, 0);
 
 	// image resources
 
@@ -298,10 +310,12 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 			const has = handler.has(imageResources);
 			const count = has === false ? 0 : (has === true ? 1 : has);
 			for (let i = 0; i < count; i++) {
+				const id = handler.keyCount > 1 ? handler.key + i : handler.key;
+				const name = handler.name ? handler.name(imageResources, i) : '';
 				writeSignature(writer, '8BIM');
-				writeUint16(writer, handler.key);
-				writePascalString(writer, '', 2);
-				writeSection(writer, 2, () => handler.write(writer, imageResources, i));
+				writeUint16(writer, id);
+				writePascalString(writer, name, 2);
+				writeSection(writer, 2, () => handler.write(writer, imageResources, i, psd));
 			}
 		}
 	});
@@ -318,19 +332,14 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 	// image data
 	writeUint16(writer, Compression.RleCompressed); // Photoshop doesn't support zip compression of composite image data
 
-	if (RAW_IMAGE_DATA && (psd as any).imageDataRaw) {
-		console.log('writing raw image data');
-		writeBytes(writer, (psd as any).imageDataRaw);
-	} else {
-		const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-		const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
+	const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
+	const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
 
-		// encode directly into the writer buffer
-		const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
-		ensureSize(writer, writer.offset + maxSize);
-		const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
-		writer.offset += writeDataRLE(buffer, data, channels, !!options.psb).length;
-	}
+	// encode directly into the writer buffer
+	const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
+	ensureSize(writer, writer.offset + maxSize);
+	const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
+	writer.offset += writeDataRLE(buffer, data, channels, !!options.psb).length;
 }
 
 function getCompositeData(imageData: PixelData | undefined, width: number, height: number, globalAlpha: boolean): PixelData {
@@ -362,7 +371,7 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 	writeSection(writer, 4, () => {
 		writeInt16(writer, globalAlpha ? -layers.length : layers.length);
 
-		const layersData = layers.map((l, i) => getChannels(writer.tempBuffer!, l, i === 0, options));
+		const layersData = layers.map((l, i) => getChannels(writer, l, i === 0, options));
 
 		// layer records
 		for (const layerData of layersData) {
@@ -419,7 +428,14 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 	}, true, options.psb);
 }
 
-function writeLayerMaskData(writer: PsdWriter, { mask, realMask }: Layer, layerData: LayerChannelData) {
+// real mask is only stored separately if layer has both vector and pixel masks, otherwise it's stored as the main mask
+function getMasks(layer: Layer) {
+	return layer.mask ? { mask: layer.mask, realMask: layer.realMask } : { mask: layer.realMask, realMask: undefined };
+}
+
+function writeLayerMaskData(writer: PsdWriter, layer: Layer, layerData: LayerChannelData) {
+	const { mask, realMask } = getMasks(layer);
+
 	writeSection(writer, 4, () => {
 		if (!mask && !realMask) return;
 
@@ -512,13 +528,13 @@ function writeAdditionalLayerInfo(writer: PsdWriter, target: LayerAdditionalInfo
 		let key = handler.key;
 
 		if (key === 'Txt2' && options.invalidateTextLayers) continue;
-		if (key === 'vmsk' && options.psb) key = 'vsms';
+		if (key === 'vmsk' && infoHandlersMap['vscg'].has(target)) key = 'vsms'; // Photoshop uses 'vsms' for layers with vector stroke
 
 		if (handler.has(target)) {
 			const large = options.psb && largeAdditionalInfoKeys.indexOf(key) !== -1;
 			const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
 			const fourBytes = key === 'levl' || key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
-				key === 'vogk' || key === 'SoLd' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
+				key === 'vogk' || key === 'SoLd' || key === 'SoLE' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
 				key === 'lmfx' || key === 'lrFX' || key === 'cinf' || key === 'PlLd' || key === 'Anno' || key === 'CAI ' || key === 'OCIO' || key === 'GenI' || key === 'FEid' || key === 'curv' || key === 'CgEd' || key === 'vibA' || key === 'blwh' || key === 'grdm';
 
 			writeSignature(writer, large ? '8B64' : '8BIM');
@@ -624,7 +640,7 @@ function createThumbnail(psd: Psd) {
 	return canvas;
 }
 
-function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, layer: Layer, mask: LayerMaskData, options: WriteOptions, realMask: boolean) {
+function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, mask: LayerMaskData, options: WriteOptions, realMask: boolean) {
 	let top = (mask.top as any) | 0;
 	let left = (mask.left as any) | 0;
 	let right = (mask.right as any) | 0;
@@ -646,10 +662,7 @@ function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, la
 	let buffer: Uint8Array;
 	let compression: Compression;
 
-	if (RAW_IMAGE_DATA && (layer as any)[realMask ? 'realMaskDataRaw' : 'maskDataRaw']) {
-		buffer = (layer as any)[realMask ? 'realMaskDataRaw' : 'maskDataRaw'];
-		compression = (layer as any)[realMask ? 'realMaskDataRawCompression' : 'maskDataRawCompression'];
-	} else if (!imageData) {
+	if (!imageData) {
 		buffer = new Uint8Array(0);
 		compression = Compression.RleCompressed;
 	} else if (options.compress) {
@@ -674,20 +687,47 @@ function bounds(obj: { top?: number; left?: number; bottom?: number; right?: num
 	} : undefined;
 }
 
-function getChannels(tempBuffer: Uint8Array, layer: Layer, background: boolean, options: WriteOptions): LayerChannelData {
+function getChannels(writer: PsdWriter, layer: Layer, background: boolean, options: WriteOptions): LayerChannelData {
+	let source = layer;
+
 	if (layer.rawData) {
-		return {
-			layer,
-			channels: layer.rawData.channels.map(c => ({ ...c, length: 2 + (c.data?.byteLength ?? 0) })),
-			...bounds(layer)!,
-			mask: bounds(layer.mask),
-			realMask: bounds(layer.realMask),
+		const { colorMode, bitsPerChannel, large } = layer.rawData;
+
+		if (large === !!options.psb && colorMode === ColorMode.RGB && bitsPerChannel === 8) {
+			// same mask mapping as in writeLayerMaskData
+			const { mask, realMask } = getMasks(layer);
+			return {
+				layer,
+				channels: layer.rawData.channels.map(c => ({ ...c, length: 2 + (c.data?.byteLength ?? 0) })),
+				...bounds(layer)!,
+				mask: bounds(mask),
+				realMask: bounds(realMask),
+			};
+		}
+
+		if (bitsPerChannel !== 8) throw new Error('Layer raw data with bitsPerChannel other than 8 is not supported for writing');
+
+		// raw data is in different format than the one we're writing, decode it so it can be re-encoded
+		source = {
+			...layer,
+			rawData: undefined,
+			canvas: undefined,
+			imageData: getLayerImageData(layer),
+			mask: layer.mask && { ...layer.mask, canvas: undefined, imageData: getLayerMaskImageData(layer) },
+			realMask: layer.realMask && { ...layer.realMask, canvas: undefined, imageData: getLayerRealMaskImageData(layer) },
 		};
+
+		// temp buffer is sized only for layers with image data, grow it and keep it for following layers
+		const size = getLargestLayerSize([{ ...source, children: undefined }], !!options.psb);
+		if (writer.tempBuffer!.byteLength < size) writer.tempBuffer = new Uint8Array(size);
 	}
 
-	const layerData = getLayerChannels(tempBuffer, layer, background, options);
-	if (layer.mask) getMaskChannels(tempBuffer, layerData, layer, layer.mask, options, false);
-	if (layer.realMask) getMaskChannels(tempBuffer, layerData, layer, layer.realMask, options, true);
+	const tempBuffer = writer.tempBuffer!;
+	const { mask, realMask } = getMasks(source);
+	const layerData = getLayerChannels(tempBuffer, source, background, options);
+	if (mask) getMaskChannels(tempBuffer, layerData, mask, options, false);
+	if (realMask) getMaskChannels(tempBuffer, layerData, realMask, options, true);
+	layerData.layer = layer;
 	return layerData;
 }
 
@@ -768,20 +808,16 @@ function getLayerChannels(tempBuffer: Uint8Array, layer: Layer, background: bool
 		ChannelID.Color2,
 	];
 
-	if (!background || options.noBackground || layer.mask || hasAlpha(imageData) || (RAW_IMAGE_DATA && (layer as any).imageDataRaw?.['-1'])) {
+	if (!background || options.noBackground || layer.mask || hasAlpha(imageData)) {
 		channelIds.unshift(ChannelID.Transparency);
 	}
 
 	channels = channelIds.map(id => {
-		const offset = offsetForChannel(id, false); // TODO: psd.colorMode === ColorMode.CMYK);
+		const offset = offsetForChannel(id, false); // image data is always RGBA
 		let data: Uint8Array;
 		let compression: Compression;
 
-		if (RAW_IMAGE_DATA && (layer as any).imageDataRaw) {
-			// console.log('written raw layer image data');
-			data = (layer as any).imageDataRaw[id];
-			compression = (layer as any).imageDataRawCompression[id];
-		} else if (options.compress) {
+		if (options.compress) {
 			data = writeDataZipWithoutPrediction(imageData, [offset]);
 			compression = Compression.ZipWithoutPrediction;
 		} else {
@@ -868,11 +904,12 @@ export function writeColor(writer: PsdWriter, color: Color | undefined) {
 		writeUint16(writer, Math.round(color.b * 0xffff));
 		writeUint16(writer, 0);
 	} else if ('c' in color) {
+		// 0 = 100% ink
 		writeUint16(writer, ColorSpace.CMYK);
-		writeUint16(writer, Math.round(color.c * 257));
-		writeUint16(writer, Math.round(color.m * 257));
-		writeUint16(writer, Math.round(color.y * 257));
-		writeUint16(writer, Math.round(color.k * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.c, 0, 255) * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.m, 0, 255) * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.y, 0, 255) * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.k, 0, 255) * 257));
 	} else {
 		writeUint16(writer, ColorSpace.Grayscale);
 		writeUint16(writer, Math.round(color.k * 10000 / 255));

package/src/text.ts

@@ -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();
 		}
 	}
@@ -671,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: {

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) {