johanels/penpot
1
0
Fork 0
mirror of https://github.com/penpot/penpot.git synced 2025-12-11 22:14:05 +01:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

♻️ Change internal naming for PathData cljs impl

Browse Source 
For make it more consistent with CLJ impl and move
the equals helper to buffers for make it reusable by
other binary types.
This commit is contained in:
Andrey Antukh
2025-05-28 14:18:57 +02:00
parent 580013bc3f
commit 3d61924162
5 changed files with 63 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
common/src/app/common/buffer.cljc
View File

@@ -129,11 +129,35 @@
(let [buffer (ByteBuffer/wrap dst)]
(.order buffer ByteOrder/LITTLE_ENDIAN)))
:cljs
(let [src-view (js/Uint32Array. buffer)
dst-buff (js/ArrayBuffer. (.-byteLength buffer))
(let [buffer' (.-buffer ^js/DataView buffer)
src-view (js/Uint32Array. buffer')
dst-buff (js/ArrayBuffer. (.-byteLength buffer'))
dst-view (js/Uint32Array. dst-buff)]
(.set dst-view src-view)
dst-buff)))
(js/DataView. dst-buff))))
(defn equals?
[buffer-a buffer-b]
#?(:clj
(.equals ^ByteBuffer buffer-a
^ByteBuffer buffer-b)
:cljs
(let [buffer-a (.-buffer buffer-a)
buffer-b (.-buffer buffer-b)]
(if (= (.-byteLength buffer-a)
(.-byteLength buffer-b))
(let [cb (js/Uint32Array. buffer-a)
ob (js/Uint32Array. buffer-b)
sz (alength cb)]
(loop [i 0]
(if (< i sz)
(if (== (aget ob i)
(aget cb i))
(recur (inc i))
false)
true)))
false))))
(defn buffer?
[o]

4
common/src/app/common/data.cljc
View File

@@ -33,6 +33,10 @@
(def boolean-or-nil?
(some-fn nil? boolean?))
(defn in-range?
[size i]
(and (< i size) (>= i 0)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Commonly used transducers
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

78
common/src/app/common/types/path/impl.cljc
View File

@@ -14,6 +14,7 @@
#?(:clj [clojure.data.json :as json])
#?(:cljs [app.common.weak-map :as weak-map])
[app.common.buffer :as buf]
[app.common.data :as d]
[app.common.data.macros :as dm]
[app.common.schema :as sm]
[app.common.schema.generators :as sg]
@@ -265,10 +266,6 @@
4 {:command :close-path
:params {}})))
(defn- in-range?
[size i]
(and (< i size) (>= i 0)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; TYPE: PATH-DATA
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -283,7 +280,7 @@
(equals [_ other]
(if (instance? PathData other)
(.equals ^ByteBuffer buffer (.-buffer ^PathData other))
(buf/equals? buffer (.-buffer ^PathData other))
false))
ITransformable
@@ -336,12 +333,12 @@
clojure.lang.Indexed
(nth [_ i]
(if (in-range? size i)
(if (d/in-range? size i)
(read-segment buffer i)
nil))
(nth [_ i default]
(if (in-range? size i)
(if (d/in-range? size i)
(read-segment buffer i)
default))
@@ -357,10 +354,10 @@
:cljs
#_:clj-kondo/ignore
(deftype PathData [size buffer dview cache ^:mutable __hash]
(deftype PathData [size buffer cache ^:mutable __hash]
Object
(toString [_]
(to-string dview size))
(to-string buffer size))
IPathData
(-get-byte-size [_]
@@ -370,56 +367,43 @@
;; NOTE: we still use u8 because until the heap refactor merge
;; we can't guarrantee the alignment of offset on 4 bytes
(assert (instance? js/ArrayBuffer into-buffer))
(let [size (.-byteLength buffer)
mem (js/Uint8Array. into-buffer offset size)]
(.set mem (js/Uint8Array. buffer))))
(let [buffer' (.-buffer ^js/DataView buffer)
size (.-byteLength buffer')
mem (js/Uint8Array. into-buffer offset size)]
(.set mem (js/Uint8Array. buffer'))))
ITransformable
(-transform [this m]
(let [buffer (buf/clone buffer)
dview (js/DataView. buffer)]
(impl-transform dview m size)
(PathData. size buffer dview (weak-map/create) nil)))
(let [buffer (buf/clone buffer)]
(impl-transform buffer m size)
(PathData. size buffer (weak-map/create) nil)))
(-walk [_ f initial]
(impl-walk dview f initial size))
(impl-walk buffer f initial size))
(-reduce [_ f initial]
(impl-reduce dview f initial size))
(impl-reduce buffer f initial size))
(-lookup [_ index f]
(when (and (<= 0 index)
(< index size))
(impl-lookup dview index f)))
(impl-lookup buffer index f)))
cljs.core/ISequential
cljs.core/IEquiv
(-equiv [this other]
(if (instance? PathData other)
(let [obuffer (.-buffer other)]
(if (= (.-byteLength obuffer)
(.-byteLength buffer))
(let [cb (js/Uint32Array. buffer)
ob (js/Uint32Array. obuffer)
sz (alength cb)]
(loop [i 0]
(if (< i sz)
(if (= (aget ob i)
(aget cb i))
(recur (inc i))
false)
true)))
false))
(buf/equals? buffer (.-buffer other))
false))
cljs.core/IReduce
(-reduce [_ f]
(loop [index 1
result (if (pos? size)
(read-segment dview 0)
(read-segment buffer 0)
nil)]
(if (< index size)
(let [result (f result (read-segment dview index))]
(let [result (f result (read-segment buffer index))]
(if (reduced? result)
@result
(recur (inc index) result)))
@@ -429,7 +413,7 @@
(loop [index 0
result start]
(if (< index size)
(let [result (f result (read-segment dview index))]
(let [result (f result (read-segment buffer index))]
(if (reduced? result)
@result
(recur (inc index) result)))
@@ -444,13 +428,13 @@
cljs.core/IIndexed
(-nth [_ i]
(if (in-range? size i)
(read-segment dview i)
(if (d/in-range? size i)
(read-segment buffer i)
nil))
(-nth [_ i default]
(if (in-range? i size)
(read-segment dview i)
(if (d/in-range? i size)
(read-segment buffer i)
default))
cljs.core/ISeqable
@@ -458,7 +442,7 @@
(when (pos? size)
((fn next-seq [i]
(when (< i size)
(cons (read-segment dview i)
(cons (read-segment buffer i)
(lazy-seq (next-seq (inc i))))))
0)))
@@ -608,17 +592,15 @@
(let [size (.-byteLength buffer)
count (long (/ size SEGMENT-BYTE-SIZE))]
(PathData. count
buffer
(js/DataView. buffer)
(weak-map/create)
nil))
(instance? js/DataView buffer)
(let [dview buffer
buffer (.-buffer dview)
size (.-byteLength buffer)
count (long (/ size SEGMENT-BYTE-SIZE))]
(PathData. count buffer dview (weak-map/create) nil))
(let [buffer' (.-buffer ^js/DataView buffer)
size (.-byteLength ^js/ArrayBuffer buffer')
count (long (/ size SEGMENT-BYTE-SIZE))]
(PathData. count buffer (weak-map/create) nil))
(instance? js/Uint8Array buffer)
(from-bytes (.-buffer buffer))
@@ -710,7 +692,7 @@
:class PathData
:wfn (fn [^PathData pdata]
(let [buffer (.-buffer pdata)]
#?(:cljs (js/Uint8Array. buffer)
#?(:cljs (js/Uint8Array. (.-buffer ^js/DataView buffer))
:clj (.array ^ByteBuffer buffer))))
:rfn from-bytes})

2
common/test/common_tests/types/path_data_test.cljc
View File

@@ -101,7 +101,7 @@
(let [pdata (path/content sample-content)]
(t/is (= sample-bytes
(vec
#?(:cljs (js/Int8Array. (.-buffer pdata))
#?(:cljs (js/Int8Array. (.-buffer (.-buffer pdata)))
:clj (.array (.-buffer pdata))))))
(t/is (= sample-content
(vec pdata)))))

1
common/test/common_tests/uuid_test.cljc
View File

@@ -18,6 +18,7 @@
(let [uuid (uuid/uuid "0227df82-63d7-8016-8005-48d9c0f33011")
result-bytes (uuid/get-bytes uuid)
expected-bytes [2 39 -33 -126 99 -41 -128 22 -128 5 72 -39 -64 -13 48 17]]
(t/testing "get-bytes"
(let [data (uuid/get-bytes uuid)]
(t/is (= (nth expected-bytes 0) (aget data 0)))