ag-psd 19.0.1 → 20.1.0

package/src/engineData2.ts

@@ -0,0 +1,367 @@
+/// Engine data 2 experiments
+// /test/engineData2.json:1109 is character codes
+
+interface KeysDict {
+	[key: string]: {
+		name?: string;
+		uproot?: boolean;
+		children?: KeysDict;
+	};
+}
+
+const keysColor: KeysDict = {
+	'0': {
+		uproot: true,
+		children: {
+			'0': { name: 'Type' },
+			'1': { name: 'Values' },
+		},
+	},
+};
+
+const keysStyleSheet: KeysDict = {
+	'0': { name: 'Font' },
+	'1': { name: 'FontSize' },
+	'2': { name: 'FauxBold' },
+	'3': { name: 'FauxItalic' },
+	'4': { name: 'AutoLeading' },
+	'5': { name: 'Leading' },
+	'6': { name: 'HorizontalScale' },
+	'7': { name: 'VerticalScale' },
+	'8': { name: 'Tracking' },
+	'9': { name: 'BaselineShift' },
+	// '10': ???
+	'11': { name: 'Kerning?' }, // different value than EngineData
+	'12': { name: 'FontCaps' },
+	'13': { name: 'FontBaseline' },
+
+	'15': { name: 'Strikethrough?' }, // number instead of bool
+	'16': { name: 'Underline?' }, // number instead of bool
+
+	'18': { name: 'Ligatures' },
+	'19': { name: 'DLigatures' },
+	// '20': ???
+	// '21': ???
+	// '22': ???
+	'23': { name: 'Fractions' }, // not present in EngineData
+	'24': { name: 'Ordinals' }, // not present in EngineData
+	// '25': ???
+	// '26': ???
+	// '27': ???
+	'28': { name: 'StylisticAlternates' }, // not present in EngineData
+	// '29': ???
+	'30': { name: 'OldStyle?' }, // OpenType > OldStyle, number instead of bool, not present in EngineData
+
+	'35': { name: 'BaselineDirection' },
+
+	'38': { name: 'Language' },
+
+	'52': { name: 'NoBreak' },
+	'53': { name: 'FillColor', children: keysColor },
+	'54': { name: 'StrokeColor?', children: keysColor },
+	'55': { children: { '99': { uproot: true } } },
+
+	// '68': ???
+
+	// '70': ???
+	// '71': ???
+	// '72': ???
+	// '73': ???
+
+	'79': { children: keysColor },
+
+	// '85': ???
+
+	// '87': ???
+	// '88': ???
+};
+
+const keysParagraph: KeysDict = {
+	'0': { name: 'Justification' },
+	'1': { name: 'FirstLineIndent' },
+	'2': { name: 'StartIndent' },
+	'3': { name: 'EndIndent' },
+	'4': { name: 'SpaceBefore' },
+	'5': { name: 'SpaceAfter' },
+
+	'7': { name: 'AutoLeading' },
+
+	'9': { name: 'AutoHyphenate' },
+	'10': { name: 'HyphenatedWordSize' },
+	'11': { name: 'PreHyphen' },
+	'12': { name: 'PostHyphen' },
+	'13': { name: 'ConsecutiveHyphens?' }, // different value than EngineData
+	'14': { name: 'Zone' },
+	'15': { name: 'HypenateCapitalizedWords' }, // not present in EngineData
+
+	'17': { name: 'WordSpacing' },
+	'18': { name: 'LetterSpacing' },
+	'19': { name: 'GlyphSpacing' },
+
+	'32': { name: 'StyleSheet', children: keysStyleSheet },
+};
+
+const keysStyleSheetData: KeysDict[''] = {
+	name: 'StyleSheetData',
+	children: keysStyleSheet,
+};
+
+const keysRoot: KeysDict = {
+	'0': {
+		name: 'ResourceDict',
+		children: {
+			'1': {
+				name: 'FontSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': {
+										uproot: true,
+										children: {
+											'0': { name: 'Name' },
+											'2': { name: 'FontType' },
+										},
+									},
+								},
+							}
+						},
+					},
+				},
+			},
+			'2': {
+				name: '2',
+				children: {},
+			},
+			'3': {
+				name: 'MojiKumiSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'InternalName' },
+								},
+							},
+						},
+					},
+				},
+			},
+			'4': {
+				name: 'KinsokuSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'Name' },
+									'5': {
+										uproot: true,
+										children: {
+											'0': { name: 'NoStart' },
+											'1': { name: 'NoEnd' },
+											'2': { name: 'Keep' },
+											'3': { name: 'Hanging' },
+											'4': { name: 'Name' },
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			'5': {
+				name: 'StyleSheetSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'Name' },
+									'6': keysStyleSheetData,
+								},
+							},
+						},
+					},
+				},
+			},
+			'6': {
+				name: 'ParagraphSheetSet',
+				children: {
+					'0': {
+						uproot: true,
+						children: {
+							'0': {
+								uproot: true,
+								children: {
+									'0': { name: 'Name' },
+									'5': {
+										name: 'Properties',
+										children: keysParagraph,
+									},
+									'6': { name: 'DefaultStyleSheet' },
+								},
+							},
+						},
+					},
+				},
+			},
+			'8': {
+				name: '8',
+				children: {},
+			},
+			'9': {
+				name: 'Predefined',
+				children: {
+					'0': {
+						children: { '0': { uproot: true } },
+					},
+					'1': {
+						children: { '0': { uproot: true } },
+					},
+				},
+			},
+		},
+	},
+	'1': {
+		name: 'EngineDict',
+		children: {
+			'0': {
+				name: '0',
+				children: {
+					// 0: ???
+					// 1: ???
+					// 2: ???
+					'3': { name: 'SuperscriptSize' },
+					'4': { name: 'SuperscriptPosition' },
+					'5': { name: 'SubscriptSize' },
+					'6': { name: 'SubscriptPosition' },
+					'7': { name: 'SmallCapSize' },
+					'8': { name: 'UseFractionalGlyphWidths' }, // ???
+
+					'15': { children: { '0': { uproot: true } } },
+					// 16: ???
+					// 17: ???
+				},
+			},
+			'1': {
+				name: 'Editors?',
+				children: {
+					'0': {
+						name: 'Editor',
+						children: {
+							'0': { name: 'Text' },
+							'5': {
+								name: 'ParagraphRun',
+								children: {
+									'0': {
+										name: 'RunArray',
+										children: {
+											'0': {
+												name: 'ParagraphSheet',
+												children: {
+													'0': {
+														uproot: true,
+														children: {
+															'0': { name: '0' },
+															'5': {
+																name: '5',
+																children: keysParagraph,
+															},
+															'6': { name: '6' },
+														},
+													},
+												},
+											},
+											'1': { name: 'RunLength' },
+										},
+									},
+								},
+							},
+							'6': {
+								name: 'StyleRun',
+								children: {
+									'0': {
+										name: 'RunArray',
+										children: {
+											'0': {
+												name: 'StyleSheet',
+												children: {
+													'0': {
+														uproot: true,
+														children: {
+															'6': keysStyleSheetData,
+														},
+													},
+												},
+											},
+											'1': { name: 'RunLength' },
+										},
+									},
+								},
+							},
+						},
+					},
+					'1': {
+						name: 'FontVectorData ???',
+						// children: {
+						// 	'0': {},
+						// 	'2': {
+						// 		// '5'
+						// 		// '6'
+						// 	},
+						// }
+					},
+				},
+			},
+			'2': {
+				name: 'StyleSheet',
+				children: keysStyleSheet,
+			},
+			'3': {
+				name: 'ParagraphSheet',
+				children: keysParagraph,
+			},
+		},
+	},
+};
+
+function decodeObj(obj: any, keys: KeysDict): any {
+	if (obj === null) return obj;
+	if (Array.isArray(obj)) return obj.map(x => decodeObj(x, keys));
+	if (typeof obj !== 'object') return obj;
+
+	let result: any = {};
+
+	for (const key of Object.keys(obj)) {
+		if (keys[key]) {
+			if (keys[key].uproot) {
+				if (key !== '99') result = decodeObj(obj[key], keys[key].children ?? {});
+				if (obj['99']) result._type = obj['99'];
+				break;
+			} else {
+				result[keys[key].name || key] = decodeObj(obj[key], keys[key].children ?? {});
+			}
+		} else if (key === '99') {
+			result._type = obj[key];
+		} else {
+			result[key] = decodeObj(obj[key], {});
+		}
+	}
+
+	return result;
+}
+
+export function decodeEngineData2(data: any) {
+	return decodeObj(data, keysRoot);
+}

package/src/helpers.ts

@@ -1,6 +1,6 @@
 import { fromByteArray } from 'base64-js';
-import { deflate } from 'pako';
-import { Layer, BlendMode, LayerColor } from './psd';
+import { deflateSync } from 'zlib';
+import { Layer, BlendMode, LayerColor, PixelData, PixelArray } from './psd';
 
 export const MOCK_HANDLERS = false;
 export const RAW_IMAGE_DATA = false;
@@ -138,14 +138,6 @@ export interface LayerChannelData {
 	mask?: Bounds;
 }
 
-export type PixelArray = Uint8ClampedArray | Uint8Array;
-
-export interface PixelData {
-	data: PixelArray;
-	width: number;
-	height: number;
-}
-
 export function offsetForChannel(channelId: ChannelID, cmyk: boolean) {
 	switch (channelId) {
 		case ChannelID.Color0: return 0;
@@ -174,26 +166,61 @@ export function hasAlpha(data: PixelData) {
 }
 
 export function resetImageData({ data }: PixelData) {
-	const buffer = new Uint32Array(data.buffer);
-	const size = buffer.length | 0;
+	const alpha = (data instanceof Float32Array) ? 1.0 : ((data instanceof Uint16Array) ? 0xffff : 0xff);
+
+	for (let p = 0, size = data.length | 0; p < size; p = (p + 4) | 0) {
+		data[p + 0] = 0;
+		data[p + 1] = 0;
+		data[p + 2] = 0;
+		data[p + 3] = alpha;
+	}
+}
+
+export function imageDataToCanvas(pixelData: PixelData) {
+	const canvas = createCanvas(pixelData.width, pixelData.height);
+	let imageData: ImageData;
 
-	for (let p = 0; p < size; p = (p + 1) | 0) {
-		buffer[p] = 0xff000000;
+	if (pixelData.data instanceof Uint8ClampedArray) {
+		imageData = pixelData as ImageData;
+	} else {
+		imageData = createImageData(pixelData.width, pixelData.height);
+		const src = pixelData.data;
+		const dst = imageData.data;
+
+		if (src instanceof Float32Array) {
+			for (let i = 0, size = src.length; i < size; i += 4) {
+				dst[i + 0] = Math.round(Math.pow(src[i + 0], 1.0 / 2.2) * 255);
+				dst[i + 1] = Math.round(Math.pow(src[i + 1], 1.0 / 2.2) * 255);
+				dst[i + 2] = Math.round(Math.pow(src[i + 2], 1.0 / 2.2) * 255);
+				dst[i + 3] = Math.round(src[i + 3] * 255);
+			}
+		} else {
+			const shift = (src instanceof Uint16Array) ? 8 : 0;
+
+			for (let i = 0, size = src.length; i < size; i++) {
+				dst[i] = src[i] >>> shift;
+			}
+		}
 	}
+
+	canvas.getContext('2d')!.putImageData(imageData, 0, 0);
+	return canvas;
 }
 
 export function decodeBitmap(input: PixelArray, output: PixelArray, width: number, height: number) {
+	if (!(input instanceof Uint8Array || input instanceof Uint8ClampedArray)) throw new Error('Invalid bit depth');
+
 	for (let y = 0, p = 0, o = 0; y < height; y++) {
 		for (let x = 0; x < width;) {
 			let b = input[o++];
 
-			for (let i = 0; i < 8 && x < width; i++, x++) {
+			for (let i = 0; i < 8 && x < width; i++, x++, p += 4) {
 				const v = b & 0x80 ? 0 : 255;
 				b = b << 1;
-				output[p++] = v;
-				output[p++] = v;
-				output[p++] = v;
-				output[p++] = 255;
+				output[p + 0] = v;
+				output[p + 1] = v;
+				output[p + 2] = v;
+				output[p + 3] = 255;
 			}
 		}
 	}
@@ -322,7 +349,7 @@ export function writeDataZipWithoutPrediction({ data, width, height }: PixelData
 			channel[i] = data[o];
 		}
 
-		const buffer = deflate(channel);
+		const buffer = deflateSync(channel);
 		buffers.push(buffer);
 		totalLength += buffer.byteLength;
 	}

package/src/imageResources.ts

@@ -98,8 +98,12 @@ addHandler(
 addHandler(
 	1060,
 	target => target.xmpMetadata !== undefined,
-	(reader, target, left) => target.xmpMetadata = readUtf8String(reader, left()),
-	(writer, target) => writeUtf8String(writer, target.xmpMetadata!),
+	(reader, target, left) => {
+		target.xmpMetadata = readUtf8String(reader, left());
+	},
+	(writer, target) => {
+		writeUtf8String(writer, target.xmpMetadata!);
+	},
 );
 
 const Inte = createEnum<RenderingIntent>('Inte', 'perceptual', {
@@ -566,6 +570,59 @@ addHandler(
 	},
 );
 
+interface LayerCompsDescriptor {
+	list: {
+		_classID: 'Comp';
+		'Nm  ': string;
+		compID: number;
+		capturedInfo: number;
+		comment?: string;
+	}[];
+	lastAppliedComp?: number;
+}
+
+addHandler(
+	1065, // Layer Comps
+	target => target.layerComps !== undefined,
+	(reader, target) => {
+		const desc = readVersionAndDescriptor(reader, true) as LayerCompsDescriptor;
+		// console.log('CompList', require('util').inspect(desc, false, 99, true));
+
+		target.layerComps = { list: [] };
+
+		for (const item of desc.list) {
+			target.layerComps.list.push({
+				id: item.compID,
+				name: item['Nm  '],
+				capturedInfo: item.capturedInfo,
+			});
+
+			if ('comment' in item) target.layerComps.list[target.layerComps.list.length - 1].comment = item.comment;
+		}
+
+		if ('lastAppliedComp' in desc) target.layerComps.lastApplied = desc.lastAppliedComp;
+	},
+	(writer, target) => {
+		const layerComps = target.layerComps!;
+		const desc: LayerCompsDescriptor = { list: [] };
+
+		for (const item of layerComps.list) {
+			const t: LayerCompsDescriptor['list'][0] = {} as any;
+			t._classID = 'Comp';
+			t['Nm  '] = item.name;
+			if ('comment' in item) t.comment = item.comment;
+			t.compID = item.id;
+			t.capturedInfo = item.capturedInfo;
+			desc.list.push(t);
+		}
+
+		if ('lastApplied' in layerComps) desc.lastAppliedComp = layerComps.lastApplied;
+
+		// console.log('CompList', require('util').inspect(desc, false, 99, true));
+		writeVersionAndDescriptor(writer, '', 'CompList', desc);
+	},
+);
+
 MOCK_HANDLERS && addHandler(
 	1092, // ???
 	target => (target as any)._ir1092 !== undefined,

package/src/psd.ts

@@ -24,7 +24,7 @@ export const enum SectionDividerType {
 
 export type RGBA = { r: number; g: number; b: number; a: number; }; // values from 0 to 255
 export type RGB = { r: number; g: number; b: number; }; // values from 0 to 255
-export type FRGB = { fr: number; fg: number; fb: number; }; // values from 0 to 1 (can be above 1)
+export type FRGB = { fr: number; fg: number; fb: number; }; // values from 0 to 1 (can be above 1, can be negative)
 export type HSB = { h: number; s: number; b: number; }; // values from 0 to 1
 export type CMYK = { c: number; m: number; y: number; k: number; }; // values from 0 to 255
 export type LAB = { l: number; a: number; b: number; }; // values `l` from 0 to 1; `a` and `b` from -1 to 1
@@ -222,6 +222,14 @@ export interface LayerEffectsInfo {
 	patternOverlay?: LayerEffectPatternOverlay; // not supported yet because of `Patt` section not implemented
 }
 
+export type PixelArray = Uint8ClampedArray | Uint8Array | Uint16Array | Float32Array;
+
+export interface PixelData {
+	data: PixelArray; // type depends on document bit depth
+	width: number;
+	height: number;
+}
+
 export interface LayerMaskData {
 	top?: number;
 	left?: number;
@@ -236,7 +244,7 @@ export interface LayerMaskData {
 	vectorMaskDensity?: number;
 	vectorMaskFeather?: number;
 	canvas?: HTMLCanvasElement;
-	imageData?: ImageData;
+	imageData?: PixelData;
 }
 
 export type TextGridding = 'none' | 'round'; // TODO: other values (no idea where to set it up in Photoshop)
@@ -416,7 +424,6 @@ export interface LayerTextData {
 	shapeType?: 'point' | 'box';
 	pointBase?: number[];
 	boxBounds?: number[];
-	
 	bounds?: UnitsBounds;
 	boundingBox?: UnitsBounds;
 }
@@ -1385,12 +1392,32 @@ export interface LayerAdditionalInfo {
 			data: Uint8Array;
 		};
 	}[];
+	comps?: {
+		originalEffectsReferencePoint?: { x: number; y: number; };
+		settings: {
+			enabled?: boolean;
+			compList: number[];
+			offset?: { x: number; y: number; };
+			effectsReferencePoint?: { x: number; y: number; };
+		}[];
+	};
+	userMask?: {
+		colorSpace: Color;
+		opacity: number;
+	};
 
 	// Base64 encoded raw EngineData, currently just kept in original state to support
 	// loading and modifying PSD file without breaking text layers.
 	engineData?: string;
 }
 
+export enum LayerCompCapturedInfo {
+	None = 0,
+	Visibility = 1,
+	Position = 2,
+	Appearance = 4,
+}
+
 export interface ImageResources {
 	layerState?: number;
 	layersGroup?: number[];
@@ -1564,6 +1591,15 @@ export interface ImageResources {
 			rightOutset?: number;
 		}[];
 	}[];
+	layerComps?: {
+		list: {
+			id: number;
+			name: string;
+			comment?: string;
+			capturedInfo: LayerCompCapturedInfo;
+		}[];
+		lastApplied?: number;
+	};
 }
 
 export interface GlobalLayerMaskInfo {
@@ -1600,7 +1636,7 @@ export interface Layer extends LayerAdditionalInfo {
 	hidden?: boolean;
 	clipping?: boolean;
 	canvas?: HTMLCanvasElement;
-	imageData?: ImageData;
+	imageData?: PixelData;
 	children?: Layer[];
 	/** Applies only for layer groups. */
 	opened?: boolean;
@@ -1614,7 +1650,7 @@ export interface Psd extends LayerAdditionalInfo {
 	colorMode?: ColorMode;
 	children?: Layer[];
 	canvas?: HTMLCanvasElement;
-	imageData?: ImageData;
+	imageData?: PixelData;
 	imageResources?: ImageResources;
 	linkedFiles?: LinkedFile[]; // used in smart objects
 	artboards?: {