fix: PSD text placement & editable

koharu-psd/src/export.rs

@@ -38,7 +38,7 @@ impl Default for PsdExportOptions {
             include_inpainted: true,
             include_segment_mask: true,
             include_brush_layer: true,
-            text_layer_mode: TextLayerMode::Rasterized,
+            text_layer_mode: TextLayerMode::Editable,
         }
     }
 }
@@ -730,15 +730,20 @@ fn is_probably_latin(text: &str) -> bool {
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
+
+    use image::DynamicImage;
     use image::{Rgba, RgbaImage};
 
     use crate::writer::PsdWriter;
 
-    use crate::input::{PsdTextBlock, PsdTextDirection, PsdTextStyle};
+    use crate::input::{
+        PsdDocument, PsdTextBlock, PsdTextDirection, PsdTextStyle, ResolvedDocument,
+    };
 
     use super::{
-        TextOrientation, contains_cjk, infer_font_name, infer_orientation, is_probably_latin,
-        place_on_canvas, write_image_data,
+        PsdExportOptions, TextLayerMode, TextOrientation, contains_cjk, export_document,
+        infer_font_name, infer_orientation, is_probably_latin, place_on_canvas, write_image_data,
     };
 
     #[test]
@@ -815,4 +820,44 @@ mod tests {
 
         assert_eq!(infer_font_name(&block), "ArialMT");
     }
+
+    #[test]
+    fn default_export_writes_editable_text_layer_metadata() {
+        let source =
+            DynamicImage::ImageRgba8(RgbaImage::from_pixel(16, 16, Rgba([255, 255, 255, 255])));
+        let document = PsdDocument {
+            width: 16,
+            height: 16,
+            text_blocks: vec![PsdTextBlock {
+                x: 2.0,
+                y: 3.0,
+                width: 10.0,
+                height: 8.0,
+                translation: Some("Hello".to_string()),
+                ..Default::default()
+            }],
+        };
+        let block_images = HashMap::new();
+        let resolved = ResolvedDocument {
+            document: &document,
+            source: &source,
+            segment: None,
+            inpainted: None,
+            rendered: None,
+            brush_layer: None,
+            block_images: &block_images,
+        };
+
+        let options = PsdExportOptions {
+            include_original: false,
+            ..Default::default()
+        };
+        assert_eq!(options.text_layer_mode, TextLayerMode::Editable);
+
+        let bytes = export_document(&resolved, &options).expect("export PSD");
+        assert!(
+            bytes.windows(4).any(|window| window == b"TySh"),
+            "editable PSD export should include text layer metadata",
+        );
+    }
 }

koharu-rpc/src/psd_export.rs

@@ -157,12 +157,17 @@ fn text_to_psd(
     transform: &koharu_core::Transform,
     text: &TextData,
 ) -> PsdTextBlock {
+    let layer_transform = match (&text.sprite, &text.sprite_transform) {
+        (Some(_), Some(sprite_transform)) => sprite_transform,
+        _ => transform,
+    };
+
     PsdTextBlock {
         id: node_id.to_string(),
-        x: transform.x,
-        y: transform.y,
-        width: transform.width,
-        height: transform.height,
+        x: layer_transform.x,
+        y: layer_transform.y,
+        width: layer_transform.width,
+        height: layer_transform.height,
         translation: text.translation.clone(),
         style: text.style.as_ref().map(convert_style),
         rendered: text.sprite.as_ref().map(blob_ref_to_psd),
@@ -220,3 +225,70 @@ fn convert_prediction(p: &FontPrediction) -> PsdFontPrediction {
 fn blob_ref_to_psd(r: &BlobRef) -> PsdBlobRef {
     PsdBlobRef::new(r.hash())
 }
+
+#[cfg(test)]
+mod tests {
+    use koharu_core::{BlobRef, NodeId, TextData, Transform};
+
+    use super::text_to_psd;
+
+    #[test]
+    fn text_to_psd_uses_sprite_transform_for_rendered_text_layer() {
+        let node_transform = Transform {
+            x: 10.0,
+            y: 20.0,
+            width: 30.0,
+            height: 40.0,
+            rotation_deg: 0.0,
+        };
+        let sprite_transform = Transform {
+            x: 100.0,
+            y: 200.0,
+            width: 300.0,
+            height: 400.0,
+            rotation_deg: 0.0,
+        };
+        let text = TextData {
+            translation: Some("Hello".to_string()),
+            sprite: Some(BlobRef::new("sprite")),
+            sprite_transform: Some(sprite_transform),
+            ..Default::default()
+        };
+
+        let block = text_to_psd(&NodeId::new(), &node_transform, &text);
+
+        assert_eq!(block.x, sprite_transform.x);
+        assert_eq!(block.y, sprite_transform.y);
+        assert_eq!(block.width, sprite_transform.width);
+        assert_eq!(block.height, sprite_transform.height);
+    }
+
+    #[test]
+    fn text_to_psd_ignores_stale_sprite_transform_without_sprite() {
+        let node_transform = Transform {
+            x: 10.0,
+            y: 20.0,
+            width: 30.0,
+            height: 40.0,
+            rotation_deg: 0.0,
+        };
+        let text = TextData {
+            translation: Some("Hello".to_string()),
+            sprite_transform: Some(Transform {
+                x: 100.0,
+                y: 200.0,
+                width: 300.0,
+                height: 400.0,
+                rotation_deg: 0.0,
+            }),
+            ..Default::default()
+        };
+
+        let block = text_to_psd(&NodeId::new(), &node_transform, &text);
+
+        assert_eq!(block.x, node_transform.x);
+        assert_eq!(block.y, node_transform.y);
+        assert_eq!(block.width, node_transform.width);
+        assert_eq!(block.height, node_transform.height);
+    }
+}