@tobyt/expo-pdf-markup 0.1.0 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md
ADDED
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
# @tobyt/expo-pdf-markup
|
|
2
|
+
|
|
3
|
+
## 0.2.0
|
|
4
|
+
|
|
5
|
+
### Minor Changes
|
|
6
|
+
|
|
7
|
+
- 78be89c: Fix freeText annotation colour lost after serialisation on iOS.
|
|
8
|
+
|
|
9
|
+
PDFKit stores freeText annotation colours in `fontColor` (not `annotation.color`, which is always `.clear` for text annotations). The `toModel` serialiser was unconditionally reading `annotation.color`, causing all freeText colours to round-trip as black. The fix reads `fontColor` for `text`/`freeText` annotation types and falls back to `annotation.color` for all others.
|
|
10
|
+
|
|
11
|
+
## 0.1.0
|
|
12
|
+
|
|
13
|
+
### Minor Changes
|
|
14
|
+
|
|
15
|
+
- Initial release.
|
|
@@ -60,7 +60,13 @@ enum AnnotationSerializer {
|
|
|
60
60
|
return nil
|
|
61
61
|
}
|
|
62
62
|
|
|
63
|
-
|
|
63
|
+
// freeText annotations store the visible colour in fontColor;
|
|
64
|
+
// annotation.color is .clear (background).
|
|
65
|
+
let isFreeText = type == "text" || type == "freeText"
|
|
66
|
+
let effectiveColor = isFreeText
|
|
67
|
+
? (annotation.fontColor ?? annotation.color ?? .black)
|
|
68
|
+
: (annotation.color ?? .red)
|
|
69
|
+
let colorHex = hexFromColor(effectiveColor)
|
|
64
70
|
var model = AnnotationModel(
|
|
65
71
|
id: id,
|
|
66
72
|
type: type,
|
|
@@ -0,0 +1,178 @@
|
|
|
1
|
+
@testable internal import ExpoPdfMarkup
|
|
2
|
+
import XCTest
|
|
3
|
+
|
|
4
|
+
final class AnnotationModelTests: XCTestCase {
|
|
5
|
+
// MARK: - Decode
|
|
6
|
+
|
|
7
|
+
func testDecodeInkAnnotation() throws {
|
|
8
|
+
let json = """
|
|
9
|
+
{
|
|
10
|
+
"version": 1,
|
|
11
|
+
"annotations": [{
|
|
12
|
+
"id": "abc-123",
|
|
13
|
+
"type": "ink",
|
|
14
|
+
"page": 0,
|
|
15
|
+
"color": "#FF0000",
|
|
16
|
+
"lineWidth": 3.0,
|
|
17
|
+
"paths": [[{"x": 10, "y": 20}, {"x": 30, "y": 40}]],
|
|
18
|
+
"createdAt": 1741340000
|
|
19
|
+
}]
|
|
20
|
+
}
|
|
21
|
+
"""
|
|
22
|
+
let data = AnnotationSerializer.deserialize(from: json)
|
|
23
|
+
XCTAssertNotNil(data)
|
|
24
|
+
XCTAssertEqual(data?.version, 1)
|
|
25
|
+
XCTAssertEqual(data?.annotations.count, 1)
|
|
26
|
+
|
|
27
|
+
let annotation = try XCTUnwrap(data?.annotations[0])
|
|
28
|
+
XCTAssertEqual(annotation.id, "abc-123")
|
|
29
|
+
XCTAssertEqual(annotation.type, "ink")
|
|
30
|
+
XCTAssertEqual(annotation.page, 0)
|
|
31
|
+
XCTAssertEqual(annotation.color, "#FF0000")
|
|
32
|
+
XCTAssertEqual(annotation.lineWidth, 3.0)
|
|
33
|
+
XCTAssertEqual(annotation.decodedPaths.count, 1)
|
|
34
|
+
XCTAssertEqual(annotation.decodedPaths[0].count, 2)
|
|
35
|
+
XCTAssertEqual(annotation.decodedPaths[0][0], AnnotationPoint(x: 10, y: 20))
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
func testDecodeHighlightAnnotation() throws {
|
|
39
|
+
let json = """
|
|
40
|
+
{
|
|
41
|
+
"version": 1,
|
|
42
|
+
"annotations": [{
|
|
43
|
+
"id": "def-456",
|
|
44
|
+
"type": "highlight",
|
|
45
|
+
"page": 1,
|
|
46
|
+
"color": "#FFFF00",
|
|
47
|
+
"alpha": 0.5,
|
|
48
|
+
"bounds": {"x": 72, "y": 340, "width": 200, "height": 14},
|
|
49
|
+
"createdAt": 1741340000
|
|
50
|
+
}]
|
|
51
|
+
}
|
|
52
|
+
"""
|
|
53
|
+
let data = AnnotationSerializer.deserialize(from: json)
|
|
54
|
+
XCTAssertNotNil(data)
|
|
55
|
+
let annotation = try XCTUnwrap(data?.annotations[0])
|
|
56
|
+
XCTAssertEqual(annotation.type, "highlight")
|
|
57
|
+
XCTAssertEqual(annotation.alpha, 0.5)
|
|
58
|
+
XCTAssertEqual(annotation.bounds, AnnotationBounds(x: 72, y: 340, width: 200, height: 14))
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
func testDecodeUnderlineAnnotation() {
|
|
62
|
+
let json = """
|
|
63
|
+
{
|
|
64
|
+
"version": 1,
|
|
65
|
+
"annotations": [{
|
|
66
|
+
"id": "ghi-789",
|
|
67
|
+
"type": "underline",
|
|
68
|
+
"page": 0,
|
|
69
|
+
"color": "#0000FF",
|
|
70
|
+
"bounds": {"x": 50, "y": 100, "width": 150, "height": 12}
|
|
71
|
+
}]
|
|
72
|
+
}
|
|
73
|
+
"""
|
|
74
|
+
let data = AnnotationSerializer.deserialize(from: json)
|
|
75
|
+
XCTAssertNotNil(data)
|
|
76
|
+
XCTAssertEqual(data?.annotations[0].type, "underline")
|
|
77
|
+
XCTAssertNil(data?.annotations[0].alpha)
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
func testDecodeTextAnnotation() {
|
|
81
|
+
let json = """
|
|
82
|
+
{
|
|
83
|
+
"version": 1,
|
|
84
|
+
"annotations": [{
|
|
85
|
+
"id": "txt-001",
|
|
86
|
+
"type": "text",
|
|
87
|
+
"page": 2,
|
|
88
|
+
"color": "#00FF00",
|
|
89
|
+
"bounds": {"x": 100, "y": 200, "width": 24, "height": 24},
|
|
90
|
+
"contents": "My note"
|
|
91
|
+
}]
|
|
92
|
+
}
|
|
93
|
+
"""
|
|
94
|
+
let data = AnnotationSerializer.deserialize(from: json)
|
|
95
|
+
XCTAssertNotNil(data)
|
|
96
|
+
XCTAssertEqual(data?.annotations[0].type, "text")
|
|
97
|
+
XCTAssertEqual(data?.annotations[0].contents, "My note")
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
func testDecodeMixedAnnotations() {
|
|
101
|
+
let json = """
|
|
102
|
+
{
|
|
103
|
+
"version": 1,
|
|
104
|
+
"annotations": [
|
|
105
|
+
{"id": "1", "type": "ink", "page": 0, "color": "#FF0000", "lineWidth": 2,
|
|
106
|
+
"paths": [[{"x": 0, "y": 0}]]},
|
|
107
|
+
{"id": "2", "type": "highlight", "page": 0, "color": "#FFFF00",
|
|
108
|
+
"bounds": {"x": 0, "y": 0, "width": 100, "height": 10}},
|
|
109
|
+
{"id": "3", "type": "text", "page": 1, "color": "#00FF00",
|
|
110
|
+
"bounds": {"x": 50, "y": 50, "width": 24, "height": 24}, "contents": "Hi"}
|
|
111
|
+
]
|
|
112
|
+
}
|
|
113
|
+
"""
|
|
114
|
+
let data = AnnotationSerializer.deserialize(from: json)
|
|
115
|
+
XCTAssertNotNil(data)
|
|
116
|
+
XCTAssertEqual(data?.annotations.count, 3)
|
|
117
|
+
XCTAssertEqual(data?.annotations[0].type, "ink")
|
|
118
|
+
XCTAssertEqual(data?.annotations[1].type, "highlight")
|
|
119
|
+
XCTAssertEqual(data?.annotations[2].type, "text")
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
func testDecodeInvalidJSON() {
|
|
123
|
+
let data = AnnotationSerializer.deserialize(from: "not json at all")
|
|
124
|
+
XCTAssertNil(data)
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
func testDecodeEmptyAnnotations() {
|
|
128
|
+
let json = """
|
|
129
|
+
{"version": 1, "annotations": []}
|
|
130
|
+
"""
|
|
131
|
+
let data = AnnotationSerializer.deserialize(from: json)
|
|
132
|
+
XCTAssertNotNil(data)
|
|
133
|
+
XCTAssertEqual(data?.annotations.count, 0)
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
// MARK: - Round-trip
|
|
137
|
+
|
|
138
|
+
func testEncodeDecodeRoundTrip() {
|
|
139
|
+
let original = AnnotationsData(
|
|
140
|
+
version: 1,
|
|
141
|
+
annotations: [
|
|
142
|
+
AnnotationModel(
|
|
143
|
+
id: "rt-1",
|
|
144
|
+
type: "ink",
|
|
145
|
+
page: 0,
|
|
146
|
+
color: "#FF0000",
|
|
147
|
+
lineWidth: 2.5,
|
|
148
|
+
paths: [[["x": 10, "y": 20], ["x": 30, "y": 40]]],
|
|
149
|
+
createdAt: 1_741_340_000
|
|
150
|
+
),
|
|
151
|
+
AnnotationModel(
|
|
152
|
+
id: "rt-2",
|
|
153
|
+
type: "highlight",
|
|
154
|
+
page: 1,
|
|
155
|
+
color: "#FFFF00",
|
|
156
|
+
alpha: 0.5,
|
|
157
|
+
bounds: AnnotationBounds(x: 72, y: 340, width: 200, height: 14),
|
|
158
|
+
createdAt: 1_741_340_000
|
|
159
|
+
),
|
|
160
|
+
]
|
|
161
|
+
)
|
|
162
|
+
|
|
163
|
+
guard let json = AnnotationSerializer.serialize(original) else {
|
|
164
|
+
XCTFail("Failed to serialize")
|
|
165
|
+
return
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
guard let decoded = AnnotationSerializer.deserialize(from: json) else {
|
|
169
|
+
XCTFail("Failed to deserialize")
|
|
170
|
+
return
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
XCTAssertEqual(decoded.version, original.version)
|
|
174
|
+
XCTAssertEqual(decoded.annotations.count, original.annotations.count)
|
|
175
|
+
XCTAssertEqual(decoded.annotations[0].id, "rt-1")
|
|
176
|
+
XCTAssertEqual(decoded.annotations[1].id, "rt-2")
|
|
177
|
+
}
|
|
178
|
+
}
|
|
@@ -0,0 +1,202 @@
|
|
|
1
|
+
@testable internal import ExpoPdfMarkup
|
|
2
|
+
import PDFKit
|
|
3
|
+
import XCTest
|
|
4
|
+
|
|
5
|
+
final class AnnotationSerializerTests: XCTestCase {
|
|
6
|
+
// MARK: - PDFAnnotation creation
|
|
7
|
+
|
|
8
|
+
func testCreateInkAnnotation() throws {
|
|
9
|
+
let model = AnnotationModel(
|
|
10
|
+
id: "ink-1",
|
|
11
|
+
type: "ink",
|
|
12
|
+
page: 0,
|
|
13
|
+
color: "#FF0000",
|
|
14
|
+
lineWidth: 3.0,
|
|
15
|
+
paths: [[["x": 10, "y": 20], ["x": 30, "y": 40]]],
|
|
16
|
+
createdAt: 1_741_340_000
|
|
17
|
+
)
|
|
18
|
+
|
|
19
|
+
let annotation = AnnotationSerializer.toPDFAnnotation(model)
|
|
20
|
+
XCTAssertNotNil(annotation)
|
|
21
|
+
XCTAssertEqual(annotation?.type, "Ink")
|
|
22
|
+
XCTAssertEqual(annotation?.border?.lineWidth, 3.0)
|
|
23
|
+
XCTAssertTrue(try AnnotationSerializer.isModuleManaged(XCTUnwrap(annotation)))
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
func testCreateHighlightAnnotation() {
|
|
27
|
+
let model = AnnotationModel(
|
|
28
|
+
id: "hl-1",
|
|
29
|
+
type: "highlight",
|
|
30
|
+
page: 0,
|
|
31
|
+
color: "#FFFF00",
|
|
32
|
+
alpha: 0.5,
|
|
33
|
+
bounds: AnnotationBounds(x: 72, y: 340, width: 200, height: 14),
|
|
34
|
+
createdAt: 1_741_340_000
|
|
35
|
+
)
|
|
36
|
+
|
|
37
|
+
let annotation = AnnotationSerializer.toPDFAnnotation(model)
|
|
38
|
+
XCTAssertNotNil(annotation)
|
|
39
|
+
XCTAssertEqual(annotation?.type, "Highlight")
|
|
40
|
+
XCTAssertEqual(annotation?.bounds, CGRect(x: 72, y: 340, width: 200, height: 14))
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
func testCreateUnderlineAnnotation() {
|
|
44
|
+
let model = AnnotationModel(
|
|
45
|
+
id: "ul-1",
|
|
46
|
+
type: "underline",
|
|
47
|
+
page: 0,
|
|
48
|
+
color: "#0000FF",
|
|
49
|
+
bounds: AnnotationBounds(x: 50, y: 100, width: 150, height: 12)
|
|
50
|
+
)
|
|
51
|
+
|
|
52
|
+
let annotation = AnnotationSerializer.toPDFAnnotation(model)
|
|
53
|
+
XCTAssertNotNil(annotation)
|
|
54
|
+
XCTAssertEqual(annotation?.type, "Underline")
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
func testCreateFreeTextAnnotation() {
|
|
58
|
+
let model = AnnotationModel(
|
|
59
|
+
id: "txt-1",
|
|
60
|
+
type: "freeText",
|
|
61
|
+
page: 0,
|
|
62
|
+
color: "#00FF00",
|
|
63
|
+
bounds: AnnotationBounds(x: 100, y: 200, width: 200, height: 24),
|
|
64
|
+
contents: "My note",
|
|
65
|
+
fontSize: 16.0
|
|
66
|
+
)
|
|
67
|
+
|
|
68
|
+
let annotation = AnnotationSerializer.toPDFAnnotation(model)
|
|
69
|
+
XCTAssertNotNil(annotation)
|
|
70
|
+
XCTAssertEqual(annotation?.type, "FreeText")
|
|
71
|
+
XCTAssertEqual(annotation?.contents, "My note")
|
|
72
|
+
XCTAssertEqual(annotation?.font?.pointSize, 16.0)
|
|
73
|
+
XCTAssertEqual(annotation?.color, .clear)
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
func testUnknownTypeReturnsNil() {
|
|
77
|
+
let model = AnnotationModel(
|
|
78
|
+
id: "bad-1",
|
|
79
|
+
type: "unknown",
|
|
80
|
+
page: 0,
|
|
81
|
+
color: "#000000"
|
|
82
|
+
)
|
|
83
|
+
|
|
84
|
+
let annotation = AnnotationSerializer.toPDFAnnotation(model)
|
|
85
|
+
XCTAssertNil(annotation)
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
// MARK: - Model extraction
|
|
89
|
+
|
|
90
|
+
func testExtractModelFromModuleManagedAnnotation() {
|
|
91
|
+
let model = AnnotationModel(
|
|
92
|
+
id: "ext-1",
|
|
93
|
+
type: "ink",
|
|
94
|
+
page: 0,
|
|
95
|
+
color: "#FF0000",
|
|
96
|
+
lineWidth: 2.0,
|
|
97
|
+
paths: [[["x": 10, "y": 20], ["x": 30, "y": 40]]],
|
|
98
|
+
createdAt: 1_741_340_000
|
|
99
|
+
)
|
|
100
|
+
|
|
101
|
+
let pdfAnnotation = try XCTUnwrap(AnnotationSerializer.toPDFAnnotation(model))
|
|
102
|
+
let extracted = AnnotationSerializer.toModel(from: pdfAnnotation, page: 0)
|
|
103
|
+
|
|
104
|
+
XCTAssertNotNil(extracted)
|
|
105
|
+
let result = try XCTUnwrap(extracted)
|
|
106
|
+
XCTAssertEqual(result.id, "ext-1")
|
|
107
|
+
XCTAssertEqual(result.type, "ink")
|
|
108
|
+
XCTAssertEqual(result.page, 0)
|
|
109
|
+
XCTAssertEqual(result.color, "#FF0000")
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
func testFreeTextColorRoundTrip() {
|
|
113
|
+
let model = AnnotationModel(
|
|
114
|
+
id: "ft-color-1",
|
|
115
|
+
type: "freeText",
|
|
116
|
+
page: 0,
|
|
117
|
+
color: "#FF0000",
|
|
118
|
+
bounds: AnnotationBounds(x: 10, y: 10, width: 100, height: 20),
|
|
119
|
+
contents: "Red text",
|
|
120
|
+
fontSize: 14.0,
|
|
121
|
+
createdAt: 1_741_340_000
|
|
122
|
+
)
|
|
123
|
+
|
|
124
|
+
let pdfAnnotation = try XCTUnwrap(AnnotationSerializer.toPDFAnnotation(model))
|
|
125
|
+
let extracted = AnnotationSerializer.toModel(from: pdfAnnotation, page: 0)
|
|
126
|
+
|
|
127
|
+
XCTAssertNotNil(extracted)
|
|
128
|
+
let result = try XCTUnwrap(extracted)
|
|
129
|
+
XCTAssertEqual(result.color, "#FF0000", "freeText color must survive a serialisation round-trip")
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
func testExtractModelFromNonManagedAnnotationReturnsNil() {
|
|
133
|
+
let annotation = PDFAnnotation(
|
|
134
|
+
bounds: CGRect(x: 0, y: 0, width: 100, height: 10),
|
|
135
|
+
forType: .highlight,
|
|
136
|
+
withProperties: nil
|
|
137
|
+
)
|
|
138
|
+
let extracted = AnnotationSerializer.toModel(from: annotation, page: 0)
|
|
139
|
+
XCTAssertNil(extracted)
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
// MARK: - Ownership filtering
|
|
143
|
+
|
|
144
|
+
func testOwnershipFiltering() {
|
|
145
|
+
let managed = PDFAnnotation(
|
|
146
|
+
bounds: CGRect(x: 0, y: 0, width: 100, height: 10),
|
|
147
|
+
forType: .highlight,
|
|
148
|
+
withProperties: nil
|
|
149
|
+
)
|
|
150
|
+
AnnotationSerializer.tagAsModuleManaged(managed, id: "owned-1", createdAt: 1_741_340_000)
|
|
151
|
+
|
|
152
|
+
let embedded = PDFAnnotation(
|
|
153
|
+
bounds: CGRect(x: 0, y: 0, width: 100, height: 10),
|
|
154
|
+
forType: .highlight,
|
|
155
|
+
withProperties: nil
|
|
156
|
+
)
|
|
157
|
+
|
|
158
|
+
XCTAssertTrue(AnnotationSerializer.isModuleManaged(managed))
|
|
159
|
+
XCTAssertFalse(AnnotationSerializer.isModuleManaged(embedded))
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
// MARK: - Color helpers
|
|
163
|
+
|
|
164
|
+
func testColorFromHex() {
|
|
165
|
+
let red = try XCTUnwrap(AnnotationSerializer.colorFromHex("#FF0000"))
|
|
166
|
+
|
|
167
|
+
var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
|
|
168
|
+
red.getRed(&r, green: &g, blue: &b, alpha: &a)
|
|
169
|
+
XCTAssertEqual(r, 1.0, accuracy: 0.01)
|
|
170
|
+
XCTAssertEqual(g, 0.0, accuracy: 0.01)
|
|
171
|
+
XCTAssertEqual(b, 0.0, accuracy: 0.01)
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
func testColorFromHexWithoutHash() {
|
|
175
|
+
let blue = try XCTUnwrap(AnnotationSerializer.colorFromHex("0000FF"))
|
|
176
|
+
|
|
177
|
+
var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
|
|
178
|
+
blue.getRed(&r, green: &g, blue: &b, alpha: &a)
|
|
179
|
+
XCTAssertEqual(b, 1.0, accuracy: 0.01)
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
func testColorFromInvalidHex() {
|
|
183
|
+
XCTAssertNil(AnnotationSerializer.colorFromHex("xyz"))
|
|
184
|
+
XCTAssertNil(AnnotationSerializer.colorFromHex("#GG0000"))
|
|
185
|
+
XCTAssertNil(AnnotationSerializer.colorFromHex(""))
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
func testHexFromColor() {
|
|
189
|
+
let hex = AnnotationSerializer.hexFromColor(.red)
|
|
190
|
+
XCTAssertEqual(hex, "#FF0000")
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
func testHexRoundTrip() {
|
|
194
|
+
let original = "#3366CC"
|
|
195
|
+
guard let color = AnnotationSerializer.colorFromHex(original) else {
|
|
196
|
+
XCTFail("Failed to parse hex")
|
|
197
|
+
return
|
|
198
|
+
}
|
|
199
|
+
let result = AnnotationSerializer.hexFromColor(color)
|
|
200
|
+
XCTAssertEqual(result, original)
|
|
201
|
+
}
|
|
202
|
+
}
|
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
@testable internal import ExpoPdfMarkup
|
|
2
|
+
import PDFKit
|
|
3
|
+
import XCTest
|
|
4
|
+
|
|
5
|
+
final class ExpoPdfMarkupViewTests: XCTestCase {
|
|
6
|
+
var view: ExpoPdfMarkupView!
|
|
7
|
+
|
|
8
|
+
override func setUp() {
|
|
9
|
+
super.setUp()
|
|
10
|
+
view = ExpoPdfMarkupView(appContext: nil)
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
override func tearDown() {
|
|
14
|
+
view = nil
|
|
15
|
+
super.tearDown()
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
// MARK: - Initial state
|
|
19
|
+
|
|
20
|
+
func testInitialState() {
|
|
21
|
+
XCTAssertNotNil(view)
|
|
22
|
+
XCTAssertTrue(view.clipsToBounds)
|
|
23
|
+
XCTAssertNil(view.pdfView.document)
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
// MARK: - loadPdf
|
|
27
|
+
|
|
28
|
+
func testLoadPdfWithValidFile() throws {
|
|
29
|
+
let bundle = Bundle(for: type(of: self))
|
|
30
|
+
guard let pdfURL = bundle.url(forResource: "test", withExtension: "pdf") else {
|
|
31
|
+
XCTFail("test.pdf not found in test bundle")
|
|
32
|
+
return
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
view.loadPdf(from: pdfURL.path)
|
|
36
|
+
XCTAssertNotNil(view.pdfView.document)
|
|
37
|
+
XCTAssertGreaterThan(try XCTUnwrap(view.pdfView.document?.pageCount), 0)
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
func testLoadPdfWithInvalidPath() {
|
|
41
|
+
view.loadPdf(from: "/nonexistent/path.pdf")
|
|
42
|
+
XCTAssertNil(view.pdfView.document)
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
func testLoadPdfSkipsDuplicateSource() {
|
|
46
|
+
let bundle = Bundle(for: type(of: self))
|
|
47
|
+
guard let pdfURL = bundle.url(forResource: "test", withExtension: "pdf") else {
|
|
48
|
+
XCTFail("test.pdf not found in test bundle")
|
|
49
|
+
return
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
view.loadPdf(from: pdfURL.path)
|
|
53
|
+
let firstDoc = view.pdfView.document
|
|
54
|
+
|
|
55
|
+
// Loading same source again should be a no-op (same document instance)
|
|
56
|
+
view.loadPdf(from: pdfURL.path)
|
|
57
|
+
XCTAssertTrue(view.pdfView.document === firstDoc)
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
// MARK: - goToPage
|
|
61
|
+
|
|
62
|
+
func testGoToPageWithNoDocument() {
|
|
63
|
+
// Should not crash when no document is loaded
|
|
64
|
+
view.goToPage(0)
|
|
65
|
+
view.goToPage(5)
|
|
66
|
+
view.goToPage(-1)
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
func testGoToPageWithValidIndex() {
|
|
70
|
+
let bundle = Bundle(for: type(of: self))
|
|
71
|
+
guard let pdfURL = bundle.url(forResource: "test", withExtension: "pdf"),
|
|
72
|
+
let doc = PDFDocument(url: pdfURL),
|
|
73
|
+
doc.pageCount > 0
|
|
74
|
+
else {
|
|
75
|
+
XCTFail("test.pdf not found or empty")
|
|
76
|
+
return
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
view.loadPdf(from: pdfURL.path)
|
|
80
|
+
view.goToPage(0)
|
|
81
|
+
|
|
82
|
+
let currentPage = view.pdfView.currentPage
|
|
83
|
+
XCTAssertNotNil(currentPage)
|
|
84
|
+
if let current = currentPage {
|
|
85
|
+
XCTAssertEqual(view.pdfView.document?.index(for: current), 0)
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
func testGoToPageRejectsNegativeIndex() {
|
|
90
|
+
let bundle = Bundle(for: type(of: self))
|
|
91
|
+
guard let pdfURL = bundle.url(forResource: "test", withExtension: "pdf") else {
|
|
92
|
+
XCTFail("test.pdf not found in test bundle")
|
|
93
|
+
return
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
view.loadPdf(from: pdfURL.path)
|
|
97
|
+
let pageBefore = view.pdfView.currentPage
|
|
98
|
+
|
|
99
|
+
view.goToPage(-1)
|
|
100
|
+
// Page should not change
|
|
101
|
+
XCTAssertEqual(view.pdfView.currentPage, pageBefore)
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
func testGoToPageRejectsOutOfBoundsIndex() throws {
|
|
105
|
+
let bundle = Bundle(for: type(of: self))
|
|
106
|
+
guard let pdfURL = bundle.url(forResource: "test", withExtension: "pdf") else {
|
|
107
|
+
XCTFail("test.pdf not found in test bundle")
|
|
108
|
+
return
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
view.loadPdf(from: pdfURL.path)
|
|
112
|
+
let pageCount = try XCTUnwrap(view.pdfView.document?.pageCount)
|
|
113
|
+
let pageBefore = view.pdfView.currentPage
|
|
114
|
+
|
|
115
|
+
view.goToPage(pageCount + 10)
|
|
116
|
+
XCTAssertEqual(view.pdfView.currentPage, pageBefore)
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
// MARK: - layoutSubviews
|
|
120
|
+
|
|
121
|
+
func testLayoutSubviewsSizesPdfView() {
|
|
122
|
+
view.frame = CGRect(x: 0, y: 0, width: 320, height: 480)
|
|
123
|
+
view.layoutSubviews()
|
|
124
|
+
|
|
125
|
+
XCTAssertEqual(view.pdfView.frame, view.bounds)
|
|
126
|
+
}
|
|
127
|
+
}
|
|
Binary file
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@tobyt/expo-pdf-markup",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.2.0",
|
|
4
4
|
"description": "An Expo module for displaying and annotating PDFs",
|
|
5
5
|
"main": "build/index.js",
|
|
6
6
|
"types": "build/index.d.ts",
|
|
@@ -29,7 +29,11 @@
|
|
|
29
29
|
"expo-module": "expo-module",
|
|
30
30
|
"open:ios": "xed example/ios",
|
|
31
31
|
"open:android": "open -a \"Android Studio\" example/android",
|
|
32
|
-
"docs": "typedoc"
|
|
32
|
+
"docs": "typedoc",
|
|
33
|
+
"changeset": "changeset",
|
|
34
|
+
"changeset:add": "changeset add",
|
|
35
|
+
"changeset:version": "changeset version",
|
|
36
|
+
"release": "bash scripts/release.sh"
|
|
33
37
|
},
|
|
34
38
|
"keywords": [
|
|
35
39
|
"react-native",
|
|
@@ -48,6 +52,7 @@
|
|
|
48
52
|
"access": "public"
|
|
49
53
|
},
|
|
50
54
|
"devDependencies": {
|
|
55
|
+
"@changesets/cli": "^2.30.0",
|
|
51
56
|
"@types/react": "~19.2.10",
|
|
52
57
|
"@types/react-test-renderer": "^19.1.0",
|
|
53
58
|
"expo": "^55.0.5",
|