ag-psd 22.0.2 → 23.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-psd",
-  "version": "22.0.2",
+  "version": "23.1.0",
   "description": "Library for reading and writing PSD files",
   "main": "dist/index.js",
   "module": "dist-es/index.js",

package/src/additionalInfo.ts

@@ -1893,6 +1893,15 @@ type SoLdDescriptorFilterItem = {
 		_classID: 'LqFy',
 		LqMe: Uint8Array;
 	};
+} | {
+	filterID: 442;
+	Fltr: {
+		_name: 'Perspective Warp';
+		_classID: 'perspectiveWarpTransform';
+		quads: { indices: number[] }[];
+		vertices: HrznVrtcDescriptor[];
+		warpedVertices: HrznVrtcDescriptor[];
+	}
 });
 
 interface SoLdDescriptorFilter {
@@ -2474,7 +2483,18 @@ function parseFilterFXItem(f: SoLdDescriptorFilterItem, options: ReadOptions): F
 						liquifyMesh: f.Fltr.LqMe,
 					},
 				};
-			}
+			};
+			case 'perspectiveWarpTransform': {
+				return {
+					...base,
+					type: 'perspective warp',
+					filter: {
+						vertices: f.Fltr.vertices.map(hrznVrtcToPoint),
+						warpedVertices: f.Fltr.warpedVertices.map(hrznVrtcToPoint),
+						quads: f.Fltr.quads.map(q => q.indices),
+					},
+				};
+			};
 			default:
 				if (options.throwForMissingFeatures) {
 					throw new Error(`Unknown filter classId: ${(f as any).Fltr._classID}`);
@@ -3154,6 +3174,17 @@ function serializeFilterFXItem(f: Filter): SoLdDescriptorFilterItem {
 			},
 			filterID: 1282492025,
 		};
+		case 'perspective warp': return {
+			...base,
+			Fltr: {
+				_name: 'Perspective Warp',
+				_classID: 'perspectiveWarpTransform',
+				vertices: f.filter.vertices.map(pointToHrznVrtc),
+				warpedVertices: f.filter.warpedVertices.map(pointToHrznVrtc),
+				quads: f.filter.quads.map(indices => ({ indices })),
+			},
+			filterID: 442,
+		};
 		default: throw new Error(`Unknow filter type: ${(f as any).type}`);
 	}
 }
@@ -3603,134 +3634,187 @@ interface FileOpenDescriptor {
 	compInfo: { compID: number; originalCompID: number; };
 }
 
-addHandler(
-	'lnk2',
-	(target: any) => !!(target as Psd).linkedFiles && (target as Psd).linkedFiles!.length > 0,
-	(reader, target, left) => {
-		const psd = target as Psd;
-		psd.linkedFiles = psd.linkedFiles || [];
-
-		while (left() > 8) {
-			let size = readLength64(reader); // size
-			const startOffset = reader.offset;
-			const type = readSignature(reader) as 'liFD' | 'liFE' | 'liFA';
-			// liFD - linked file data
-			// liFE - linked file external
-			// liFA - linked file alias
-			const version = readInt32(reader);
-			const id = readPascalString(reader, 1);
-			const name = readUnicodeString(reader);
-
-			const fileType = readSignature(reader).trim(); // '    ' if empty
-			const fileCreator = readSignature(reader).trim(); // '    ' or '\0\0\0\0' if empty
-			const dataSize = readLength64(reader);
-			const hasFileOpenDescriptor = readUint8(reader);
-			const fileOpenDescriptor = hasFileOpenDescriptor ? readVersionAndDescriptor(reader) as FileOpenDescriptor : undefined;
-			const linkedFileDescriptor = type === 'liFE' ? readVersionAndDescriptor(reader) : undefined;
-			const file: LinkedFile = { id, name };
-
-			if (fileType) file.type = fileType;
-			if (fileCreator) file.creator = fileCreator;
-
-			if (fileOpenDescriptor) {
-				file.descriptor = {
-					compInfo: {
-						compID: fileOpenDescriptor.compInfo.compID,
-						originalCompID: fileOpenDescriptor.compInfo.originalCompID,
-					}
-				};
-			}
+interface LinkedFileDescriptor {
+	descVersion: 2;
+	'Nm  ': string;
+	fullPath: string;
+	originalPath: string;
+	relPath: string;
+}
 
-			if (type === 'liFE' && version > 3) {
-				const year = readInt32(reader);
-				const month = readUint8(reader);
-				const day = readUint8(reader);
-				const hour = readUint8(reader);
-				const minute = readUint8(reader);
-				const seconds = readFloat64(reader);
-				const wholeSeconds = Math.floor(seconds);
-				const ms = (seconds - wholeSeconds) * 1000;
-				file.time = (new Date(year, month, day, hour, minute, wholeSeconds, ms)).toISOString();
+function createLnkHandler(tag: string) {
+	addHandler(
+		tag,
+		(target: any) => {
+			const psd = target as Psd;
+			if (!psd.linkedFiles || !psd.linkedFiles.length) return false;
+			if (tag === 'lnkE' && !psd.linkedFiles.some(f => f.linkedFile)) return false;
+			return true;
+		},
+		(reader, target, left, _psd) => {
+			const psd = target as Psd;
+			psd.linkedFiles = psd.linkedFiles || [];
+
+			while (left() > 8) {
+				let size = readLength64(reader);
+				const startOffset = reader.offset;
+				const type = readSignature(reader) as 'liFD' | 'liFE' | 'liFA';
+				// liFD - linked file data
+				// liFE - linked file external
+				// liFA - linked file alias
+				const version = readInt32(reader);
+				const id = readPascalString(reader, 1);
+				const name = readUnicodeString(reader);
+
+				const fileType = readSignature(reader).trim(); // '    ' if empty
+				const fileCreator = readSignature(reader).trim(); // '    ' or '\0\0\0\0' if empty
+				const dataSize = readLength64(reader);
+				const hasFileOpenDescriptor = readUint8(reader);
+				const fileOpenDescriptor = hasFileOpenDescriptor ? readVersionAndDescriptor(reader) as FileOpenDescriptor : undefined;
+				const linkedFileDescriptor = type === 'liFE' ? readVersionAndDescriptor(reader) as LinkedFileDescriptor : undefined;
+				const file: LinkedFile = { id, name };
+
+				if (fileType) file.type = fileType;
+				if (fileCreator) file.creator = fileCreator;
+
+				if (fileOpenDescriptor) {
+					file.descriptor = {
+						compInfo: {
+							compID: fileOpenDescriptor.compInfo.compID,
+							originalCompID: fileOpenDescriptor.compInfo.originalCompID,
+						}
+					};
+				}
+
+				if (type === 'liFE' && version > 3) {
+					const year = readInt32(reader);
+					const month = readUint8(reader);
+					const day = readUint8(reader);
+					const hour = readUint8(reader);
+					const minute = readUint8(reader);
+					const seconds = readFloat64(reader);
+					const wholeSeconds = Math.floor(seconds);
+					const ms = (seconds - wholeSeconds) * 1000;
+					file.time = (new Date(Date.UTC(year, month, day, hour, minute, wholeSeconds, ms))).toISOString();
+				}
+
+				const fileSize = type === 'liFE' ? readLength64(reader) : 0;
+
+				if (type === 'liFA') skipBytes(reader, 8);
+				if (type === 'liFD') file.data = readBytes(reader, dataSize); // seems to be a typo in docs
+				if (version >= 5) file.childDocumentID = readUnicodeString(reader);
+				if (version >= 6) file.assetModTime = readFloat64(reader);
+				if (version >= 7) file.assetLockedState = readUint8(reader);
+				if (type === 'liFE' && version === 2) file.data = readBytes(reader, fileSize);
+
+				if (reader.skipLinkedFilesData) file.data = undefined;
+
+				if (tag === 'lnkE') {
+					file.linkedFile = {
+						fileSize,
+						name: linkedFileDescriptor?.['Nm  '] || '',
+						fullPath: linkedFileDescriptor?.fullPath || '',
+						originalPath: linkedFileDescriptor?.originalPath || '',
+						relativePath: linkedFileDescriptor?.relPath || '',
+					};
+				}
+
+				psd.linkedFiles.push(file);
+
+				while (size % 4) size++;
+				reader.offset = startOffset + size;
 			}
 
-			const fileSize = type === 'liFE' ? readLength64(reader) : 0;
-			if (type === 'liFA') skipBytes(reader, 8);
-			if (type === 'liFD') file.data = readBytes(reader, dataSize); // seems to be a typo in docs
-			if (version >= 5) file.childDocumentID = readUnicodeString(reader);
-			if (version >= 6) file.assetModTime = readFloat64(reader);
-			if (version >= 7) file.assetLockedState = readUint8(reader);
-			if (type === 'liFE' && version === 2) file.data = readBytes(reader, fileSize);
+			skipBytes(reader, left()); // ?
+		},
+		(writer, target) => {
+			const psd = target as Psd;
 
-			if (reader.skipLinkedFilesData) file.data = undefined;
+			for (const file of psd.linkedFiles!) {
+				if ((tag === 'lnkE') !== !!file.linkedFile) continue;
 
-			psd.linkedFiles.push(file);
-			linkedFileDescriptor;
+				let version = 2;
 
-			while (size % 4) size++;
-			reader.offset = startOffset + size;
-		}
+				if (file.assetLockedState != null) version = 7;
+				else if (file.assetModTime != null) version = 6;
+				else if (file.childDocumentID != null) version = 5;
+				else if (tag == 'lnkE') version = 3;
 
-		skipBytes(reader, left()); // ?
-	},
-	(writer, target) => {
-		const psd = target as Psd;
+				writeLength64(writer, 0);
 
-		for (const file of psd.linkedFiles!) {
-			let version = 2;
+				const sizeOffset = writer.offset;
+				writeSignature(writer, (tag === 'lnkE') ? 'liFE' : (file.data ? 'liFD' : 'liFA'));
+				writeInt32(writer, version);
+				if (!file.id || typeof file.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(file.id)) {
+					throw new Error('Linked file ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
+				}
+				writePascalString(writer, file.id, 1);
+				writeUnicodeStringWithPadding(writer, file.name || '');
+				writeSignature(writer, file.type ? `${file.type}    `.substring(0, 4) : '    ');
+				writeSignature(writer, file.creator ? `${file.creator}    `.substring(0, 4) : '\0\0\0\0');
+				writeLength64(writer, file.data ? file.data.byteLength : 0);
+
+				if (file.descriptor && file.descriptor.compInfo) {
+					const desc: FileOpenDescriptor = {
+						compInfo: {
+							compID: file.descriptor.compInfo.compID,
+							originalCompID: file.descriptor.compInfo.originalCompID,
+						},
+					};
 
-			if (file.assetLockedState != null) version = 7;
-			else if (file.assetModTime != null) version = 6;
-			else if (file.childDocumentID != null) version = 5;
-			// TODO: else if (file.time != null) version = 3; (only for liFE)
+					writeUint8(writer, 1);
+					writeVersionAndDescriptor(writer, '', 'null', desc);
+				} else {
+					writeUint8(writer, 0);
+				}
 
-			writeUint32(writer, 0);
-			writeUint32(writer, 0); // size
-			const sizeOffset = writer.offset;
-			writeSignature(writer, file.data ? 'liFD' : 'liFA');
-			writeInt32(writer, version);
-			if (!file.id || typeof file.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(file.id)) {
-				throw new Error('Linked file ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
-			}
-			writePascalString(writer, file.id, 1);
-			writeUnicodeStringWithPadding(writer, file.name || '');
-			writeSignature(writer, file.type ? `${file.type}    `.substring(0, 4) : '    ');
-			writeSignature(writer, file.creator ? `${file.creator}    `.substring(0, 4) : '\0\0\0\0');
-			writeLength64(writer, file.data ? file.data.byteLength : 0);
-
-			if (file.descriptor && file.descriptor.compInfo) {
-				const desc: FileOpenDescriptor = {
-					compInfo: {
-						compID: file.descriptor.compInfo.compID,
-						originalCompID: file.descriptor.compInfo.originalCompID,
-					}
-				};
+				if (tag === 'lnkE') {
+					const desc: LinkedFileDescriptor = {
+						descVersion: 2,
+						'Nm  ': file.linkedFile?.name ?? '',
+						fullPath: file.linkedFile?.fullPath ?? '',
+						originalPath: file.linkedFile?.originalPath ?? '',
+						relPath: file.linkedFile?.relativePath ?? '',
+					};
 
-				writeUint8(writer, 1);
-				writeVersionAndDescriptor(writer, '', 'null', desc);
-			} else {
-				writeUint8(writer, 0);
-			}
+					writeVersionAndDescriptor(writer, '', 'ExternalFileLink', desc);
+
+					const time = file.time ? new Date(file.time) : new Date();
+					writeInt32(writer, time.getUTCFullYear());
+					writeUint8(writer, time.getUTCMonth());
+					writeUint8(writer, time.getUTCDate());
+					writeUint8(writer, time.getUTCHours());
+					writeUint8(writer, time.getUTCMinutes());
+					writeFloat64(writer, time.getUTCSeconds() + time.getUTCMilliseconds() / 1000);
+				}
+
+				if (file.data) {
+					writeBytes(writer, file.data);
+				} else {
+					writeLength64(writer, file.linkedFile?.fileSize || 0);
+				}
 
-			if (file.data) writeBytes(writer, file.data);
-			else writeLength64(writer, 0);
-			if (version >= 5) writeUnicodeStringWithPadding(writer, file.childDocumentID || '');
-			if (version >= 6) writeFloat64(writer, file.assetModTime || 0);
-			if (version >= 7) writeUint8(writer, file.assetLockedState || 0);
+				if (version >= 5) writeUnicodeStringWithPadding(writer, file.childDocumentID || '');
+				if (version >= 6) writeFloat64(writer, file.assetModTime || 0);
+				if (version >= 7) writeUint8(writer, file.assetLockedState || 0);
 
-			let size = writer.offset - sizeOffset;
-			writer.view.setUint32(sizeOffset - 4, size, false); // write size
+				let size = writer.offset - sizeOffset;
+				writer.view.setUint32(sizeOffset - 4, size, false); // write size
 
-			while (size % 4) {
-				size++;
-				writeUint8(writer, 0);
+				while (size % 4) {
+					size++;
+					writeUint8(writer, 0);
+				}
 			}
-		}
-	},
-);
+		},
+	);
+}
+
+createLnkHandler('lnk2');
+createLnkHandler('lnkE');
 
 addHandlerAlias('lnkD', 'lnk2');
 addHandlerAlias('lnk3', 'lnk2');
-addHandlerAlias('lnkE', 'lnk2');
 
 interface PthsDescriptor {
 	pathList: {

package/src/descriptor.ts

@@ -178,7 +178,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'Txt ', 'printerName', 'Nm  ', 'Idnt', 'blackAndWhitePresetFileName', 'LUT3DFileName',
 		'presetFileName', 'curvesPresetFileName', 'mixerPresetFileName', 'placed', 'description', 'reason',
 		'artboardPresetName', 'json', 'clipID', 'relPath', 'fullPath', 'mediaDescriptor', 'Msge',
-		'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment',
+		'altTag', 'url', 'cellText', 'preset', 'KnNm', 'FPth', 'comment', 'originalPath',
 	],
 	'tdta': [
 		'EngineData', 'LUT3DFileData', 'indexArray', 'originalVertexArray', 'deformedVertexArray',
@@ -935,7 +935,13 @@ export interface WarpDescriptor {
 		Left: DescriptorUnitsValue;
 		Btom: DescriptorUnitsValue;
 		Rght: DescriptorUnitsValue;
-	};
+	} | {
+		_classID: 'classFloatRect',
+		'Top ': number,
+		Left: number,
+		Btom: number,
+		Rght: number,
+	},
 	uOrder: number;
 	vOrder: number;
 	customEnvelopeWarp?: {

package/src/index.ts

@@ -1,12 +1,13 @@
 import { Psd, ReadOptions, WriteOptions } from './psd';
 import { PsdWriter, writePsd as writePsdInternal, getWriterBuffer, createWriter, getWriterBufferNoCopy } from './psdWriter';
 import { PsdReader, readPsd as readPsdInternal, createReader } from './psdReader';
+import { fromByteArray } from 'base64-js';
+
 export * from './abr';
 export * from './csh';
 export { initializeCanvas } from './helpers';
 export * from './psd';
-import { fromByteArray } from 'base64-js';
-export { PsdReader, PsdWriter };
+export type { PsdReader, PsdWriter };
 
 interface BufferLike {
 	buffer: ArrayBuffer;

package/src/psd.ts

@@ -678,7 +678,7 @@ export interface SelectiveColorAdjustment {
 	blacks?: CMYK;
 }
 
-export interface LinkedFile {
+export type LinkedFile = {
 	id: string; // must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)
 	name: string;
 	type?: string;
@@ -691,6 +691,15 @@ export interface LinkedFile {
 	childDocumentID?: string;
 	assetModTime?: number;
 	assetLockedState?: number;
+
+	// external files
+	linkedFile?: {
+		fileSize: number;
+		name: string;
+		fullPath: string;
+		originalPath: string;
+		relativePath: string;
+	};
 }
 
 type FilterVariant = {
@@ -1110,6 +1119,13 @@ type FilterVariant = {
 	filter: {
 		liquifyMesh: Uint8Array;
 	};
+} | {
+	type: 'perspective warp';
+	filter: {
+		quads: number[][]; // quad indices
+		vertices: { x: UnitsValue; y: UnitsValue; }[];
+		warpedVertices: { x: UnitsValue; y: UnitsValue; }[];
+	}
 };
 
 /*

package/src/psdWriter.ts

@@ -476,13 +476,6 @@ function addChildren(layers: Layer[], children: Layer[] | undefined) {
 				sectionDivider: {
 					type: SectionDividerType.BoundingSectionDivider,
 				},
-				// TESTING
-				// nameSource: 'lset',
-				// id: [4, 0, 0, 8, 11, 0, 0, 0, 0, 14][layers.length] || 0,
-				// layerColor: 'none',
-				// timestamp: [1611346817.349021, 0, 0, 1611346817.349175, 1611346817.3491833, 0, 0, 0, 0, 1611346817.349832][layers.length] || 0,
-				// protected: {},
-				// referencePoint: { x: 0, y: 0 },
 			});
 			addChildren(layers, c.children);
 			layers.push({