;; Hyperscript behavioral tests — auto-generated from upstream _hyperscript test suite
;; Source: spec/tests/hyperscript-upstream-tests.json (1496 tests, v0.9.14 + dev)
;; DO NOT EDIT — regenerate with: python3 tests/playwright/generate-sx-tests.py
;; ── Test helpers ──────────────────────────────────────────────────
(define hs-test-el
(fn (tag hs-src)
(let ((el (dom-create-element tag)))
(dom-set-attr el "_" hs-src)
(dom-append (dom-body) el)
(hs-activate! el)
el)))
(define hs-cleanup!
(fn ()
(dom-set-inner-html (dom-body) "")))
;; Evaluate a hyperscript expression and return the last-expression value.
;; Compiles the expression, wraps in a thunk, evaluates, returns result.
(define eval-hs
(fn (src)
(let ((sx (hs-to-sx (hs-compile src))))
(let ((handler (eval-expr-cek
(list (quote fn) (list (quote me)) (list (quote let) (list (list (quote it) nil) (list (quote event) nil)) sx)))))
(guard
(_e
(true
(if
(and (list? _e) (= (first _e) "hs-return"))
(nth _e 1)
(raise _e))))
(handler nil))))))
;; Evaluate a hyperscript expression with locals. bindings = list of (symbol value).
;; The locals are injected as fn params so they resolve in the handler body.
(define eval-hs-locals
(fn (src bindings)
(let ((sx (hs-to-sx (hs-compile src))))
(let ((names (map (fn (b) (first b)) bindings))
(vals (map (fn (b) (nth b 1)) bindings)))
(let ((param-list (cons (quote me) names)))
(let ((wrapper (list (quote fn) param-list
(list (quote let)
(list (list (quote it) nil) (list (quote event) nil))
sx (quote it)))))
(let ((handler (eval-expr-cek wrapper)))
(guard
(_e
(true
(if
(and (list? _e) (= (first _e) "hs-return"))
(nth _e 1)
(raise _e))))
(apply handler (cons nil vals))))))))))
;; Evaluate with a specific me value (for "I am between" etc.)
(define eval-hs-with-me
(fn (src me-val)
(let ((sx (hs-to-sx (hs-compile src))))
(let ((handler (eval-expr-cek
(list (quote fn) (list (quote me)) (list (quote let) (list (list (quote it) nil) (list (quote event) nil)) sx)))))
(guard
(_e
(true
(if
(and (list? _e) (= (first _e) "hs-return"))
(nth _e 1)
(raise _e))))
(handler me-val))))))
;; ── add (19 tests) ──
(defsuite "hs-upstream-add"
(deftest "can add a value to a set"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set :s to [] as Set then add 'a' to :s then add 'b' to :s then add 'a' to :s then put :s.size into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "2")
))
(deftest "can add a value to an array"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set :arr to [1,2,3] then add 4 to :arr then put :arr as String into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "1,2,3,4")
))
(deftest "can add class ref on a single div"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click add .foo")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (dom-has-class? _el-div "foo"))
))
(deftest "can add class ref on a single form"
(hs-cleanup!)
(let ((_el-form (dom-create-element "form")))
(dom-set-attr _el-form "_" "on click add .foo")
(dom-append (dom-body) _el-form)
(hs-activate! _el-form)
(dom-dispatch _el-form "click" nil)
(assert (dom-has-class? _el-form "foo"))
))
(deftest "can add class ref w/ double dash on a single div"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click add .foo--bar")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (dom-has-class? _el-div "foo--bar"))
))
(deftest "can add class refs w/ colons and dashes"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click add .foo:bar-doh")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (dom-has-class? _el-div "foo:bar-doh"))
))
(deftest "can add css properties"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click add {color: red; font-family: monospace}")
(dom-set-attr _el-div "style" "color: blue")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-get-style _el-div "color") "")
(assert= (dom-get-style _el-div "font-family") "monospace")
))
(deftest "can add multiple class refs"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click add .foo .bar")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (dom-has-class? _el-div "foo"))
(assert (dom-has-class? _el-div "bar"))
))
(deftest "can add non-class attributes"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click add [@foo=\"bar\"]")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-get-attr _el-div "foo") "bar")
))
(deftest "can add templated css properties"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click add {color: ${}{\"red\"};}")
(dom-set-attr _el-div "style" "color: blue")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-get-style _el-div "color") "")
))
(deftest "can add to an HTMLCollection"
(hs-cleanup!)
(let ((_el-trigger (dom-create-element "div")) (_el-bar (dom-create-element "div")) (_el-c1 (dom-create-element "div")) (_el-c2 (dom-create-element "div")))
(dom-set-attr _el-trigger "id" "trigger")
(dom-set-attr _el-trigger "_" "on click add .foo to the children of #bar")
(dom-set-attr _el-bar "id" "bar")
(dom-set-attr _el-c1 "id" "c1")
(dom-set-attr _el-c2 "id" "c2")
(dom-append (dom-body) _el-trigger)
(dom-append (dom-body) _el-bar)
(dom-append _el-bar _el-c1)
(dom-append _el-bar _el-c2)
(hs-activate! _el-trigger)
(dom-dispatch (dom-query-by-id "trigger") "click" nil)
(assert (dom-has-class? (dom-query-by-id "c1") "foo"))
(assert (dom-has-class? (dom-query-by-id "c2") "foo"))
))
(deftest "can add to children"
(hs-cleanup!)
(let ((_el-outer (dom-create-element "div")) (_el-p1 (dom-create-element "p")))
(dom-set-attr _el-outer "id" "outer")
(dom-set-attr _el-outer "_" "on click add .foo to my children")
(dom-set-attr _el-p1 "id" "p1")
(dom-append (dom-body) _el-outer)
(dom-append _el-outer _el-p1)
(hs-activate! _el-outer)
(dom-dispatch (dom-query-by-id "outer") "click" nil)
(assert (dom-has-class? (dom-query-by-id "p1") "foo"))
(assert (not (dom-has-class? (dom-query-by-id "outer") "foo")))
))
(deftest "can add to query in me"
(hs-cleanup!)
(let ((_el-outer (dom-create-element "div")) (_el-p1 (dom-create-element "p")))
(dom-set-attr _el-outer "id" "outer")
(dom-set-attr _el-outer "_" "on click add .foo to
in me")
(dom-set-attr _el-p1 "id" "p1")
(dom-append (dom-body) _el-outer)
(dom-append _el-outer _el-p1)
(hs-activate! _el-outer)
(dom-dispatch (dom-query-by-id "outer") "click" nil)
(assert (dom-has-class? (dom-query-by-id "p1") "foo"))
(assert (not (dom-has-class? (dom-query-by-id "outer") "foo")))
))
(deftest "can filter class addition via the when clause"
(hs-cleanup!)
(let ((_el-trigger (dom-create-element "div")) (_el-d2 (dom-create-element "div")) (_el-d3 (dom-create-element "div")))
(dom-set-attr _el-trigger "id" "trigger")
(dom-set-attr _el-trigger "_" "on click add .rey to .bar when it matches .doh")
(dom-set-attr _el-d2 "id" "d2")
(dom-add-class _el-d2 "bar")
(dom-set-attr _el-d3 "id" "d3")
(dom-add-class _el-d3 "bar")
(dom-add-class _el-d3 "doh")
(dom-append (dom-body) _el-trigger)
(dom-append (dom-body) _el-d2)
(dom-append (dom-body) _el-d3)
(hs-activate! _el-trigger)
(dom-dispatch (dom-query-by-id "trigger") "click" nil)
(assert (not (dom-has-class? (dom-query-by-id "d2") "rey")))
(assert (dom-has-class? (dom-query-by-id "d3") "rey"))
))
(deftest "can filter property addition via the when clause"
(hs-cleanup!)
(let ((_el-trigger (dom-create-element "div")) (_el-d2 (dom-create-element "div")) (_el-d3 (dom-create-element "div")))
(dom-set-attr _el-trigger "id" "trigger")
(dom-set-attr _el-trigger "_" "on click add @rey to .bar when it matches .doh")
(dom-set-attr _el-d2 "id" "d2")
(dom-add-class _el-d2 "bar")
(dom-set-attr _el-d3 "id" "d3")
(dom-add-class _el-d3 "bar")
(dom-add-class _el-d3 "doh")
(dom-append (dom-body) _el-trigger)
(dom-append (dom-body) _el-d2)
(dom-append (dom-body) _el-d3)
(hs-activate! _el-trigger)
(dom-dispatch (dom-query-by-id "trigger") "click" nil)
(assert (not (dom-has-attr? (dom-query-by-id "d2") "rey")))
(assert (dom-has-attr? (dom-query-by-id "d3") "rey"))
))
(deftest "can target another div for class ref"
(hs-cleanup!)
(let ((_el-bar (dom-create-element "div")) (_el-trigger (dom-create-element "div")))
(dom-set-attr _el-bar "id" "bar")
(dom-set-attr _el-trigger "id" "trigger")
(dom-set-attr _el-trigger "_" "on click add .foo to #bar")
(dom-append (dom-body) _el-bar)
(dom-append (dom-body) _el-trigger)
(hs-activate! _el-trigger)
(dom-dispatch (dom-query-by-id "trigger") "click" nil)
(assert (dom-has-class? (dom-query-by-id "bar") "foo"))
(assert (not (dom-has-class? (dom-query-by-id "trigger") "foo")))
))
(deftest "supports async expressions in when clause"
(hs-cleanup!)
(let ((_el-trigger (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
(dom-set-attr _el-trigger "id" "trigger")
(dom-set-attr _el-trigger "_" "on click add .foo to #d2 when asyncCheck()")
(dom-set-attr _el-d2 "id" "d2")
(dom-append (dom-body) _el-trigger)
(dom-append (dom-body) _el-d2)
(hs-activate! _el-trigger)
(dom-dispatch (dom-query-by-id "trigger") "click" nil)
(assert (dom-has-class? (dom-query-by-id "d2") "foo"))
))
(deftest "when clause result is empty when nothing matches"
(hs-cleanup!)
(let ((_el-trigger (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-none (dom-create-element "div")))
(dom-set-attr _el-trigger "id" "trigger")
(dom-set-attr _el-trigger "_" "on click add .foo to .item when it matches .nope then if the result is empty remove @hidden from #none")
(dom-set-attr _el-d1 "id" "d1")
(dom-add-class _el-d1 "item")
(dom-set-attr _el-none "id" "none")
(dom-set-attr _el-none "hidden" "")
(dom-append (dom-body) _el-trigger)
(dom-append (dom-body) _el-d1)
(dom-append (dom-body) _el-none)
(hs-activate! _el-trigger)
(dom-dispatch (dom-query-by-id "trigger") "click" nil)
(assert (not (dom-has-attr? (dom-query-by-id "none") "hidden")))
))
(deftest "when clause sets result to matched elements"
(hs-cleanup!)
(let ((_el-trigger (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")) (_el-none (dom-create-element "div")))
(dom-set-attr _el-trigger "id" "trigger")
(dom-set-attr _el-trigger "_" "on click add .foo to .item when it matches .yes then if the result is empty show #none else hide #none")
(dom-set-attr _el-d1 "id" "d1")
(dom-add-class _el-d1 "item")
(dom-add-class _el-d1 "yes")
(dom-set-attr _el-d2 "id" "d2")
(dom-add-class _el-d2 "item")
(dom-set-attr _el-none "id" "none")
(dom-set-attr _el-none "style" "display:none")
(dom-append (dom-body) _el-trigger)
(dom-append (dom-body) _el-d1)
(dom-append (dom-body) _el-d2)
(dom-append (dom-body) _el-none)
(hs-activate! _el-trigger)
(dom-dispatch (dom-query-by-id "trigger") "click" nil)
(assert (not (dom-visible? (dom-query-by-id "none"))))
))
)
;; ── append (13 tests) ──
(defsuite "hs-upstream-append"
(deftest "append preserves existing content rather than overwriting it"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-btn1 (dom-create-element "button")))
(dom-set-attr _el-div "_" "on click append 'New Content ' to me")
(dom-set-attr _el-btn1 "id" "btn1")
(dom-set-inner-html _el-btn1 "Click Me")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-btn1)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
))
(deftest "append to undefined ignores the undefined"
(hs-cleanup!)
(let ((_el-id (dom-create-element "div")))
(dom-set-attr _el-id "id" "id")
(dom-set-attr _el-id "_" "on click append 'bar' then append it to me")
(dom-append (dom-body) _el-id)
(hs-activate! _el-id)
(dom-dispatch _el-id "click" nil)
(assert= (dom-text-content _el-id) "bar")
))
(deftest "can append a string to another string"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set value to 'Hello there.' then append ' General Kenobi.' to value then set my.innerHTML to value")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "Hello there. General Kenobi.")
))
(deftest "can append a value into an array"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set value to [1,2,3] then append 4 to value then set my.innerHTML to value as String")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "1,2,3,4")
))
(deftest "can append a value to 'it'"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set result to [1,2,3] then append 4 then put it as String into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "1,2,3,4")
))
(deftest "can append a value to I"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click append 'Content' to I")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "Content")
))
(deftest "can append a value to a DOM element"
(hs-cleanup!)
(let ((_el-content (dom-create-element "div")))
(dom-set-attr _el-content "id" "content")
(dom-set-attr _el-content "_" "on click append 'Content' to #content")
(dom-append (dom-body) _el-content)
(hs-activate! _el-content)
(dom-dispatch _el-content "click" nil)
(assert= (dom-text-content _el-content) "Content")
))
(deftest "can append a value to a DOM node"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click append 'This is my inner HTML ' to me then append 'With Tags ' to me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "This is my inner HTMLWith Tags")
))
(deftest "can append a value to a set"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set :s to [1,2] as Set then append 3 to :s then append 1 to :s then put :s.size into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "3")
))
(deftest "can append a value to an object property"
(hs-cleanup!)
(let ((_el-id (dom-create-element "div")))
(dom-set-attr _el-id "id" "id")
(dom-set-attr _el-id "_" "on click append '_new' to my id")
(dom-append (dom-body) _el-id)
(hs-activate! _el-id)
(dom-dispatch _el-id "click" nil)
))
(deftest "multiple appends work"
(hs-cleanup!)
(let ((_el-id (dom-create-element "div")))
(dom-set-attr _el-id "id" "id")
(dom-set-attr _el-id "_" "on click get 'foo' then append 'bar' then append 'doh' then append it to me")
(dom-append (dom-body) _el-id)
(hs-activate! _el-id)
(dom-dispatch _el-id "click" nil)
(assert= (dom-text-content _el-id) "foobardoh")
))
(deftest "new DOM content added by append will be live"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click make a Test ` to me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(dom-dispatch (dom-query-by-id "b1") "click" nil)
))
)
;; ── askAnswer (5 tests) ──
(defsuite "hs-upstream-askAnswer"
(deftest "confirm returns first choice on OK"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")) (_el-out (dom-create-element "div")))
(dom-set-attr _el-button "_" "on click answer \"Save?\" with \"Yes\" or \"No\" then put it into #out")
(dom-set-inner-html _el-button "Go")
(dom-set-attr _el-out "id" "out")
(dom-append (dom-body) _el-button)
(dom-append (dom-body) _el-out)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "out")) "Yes")
))
(deftest "confirm returns second choice on cancel"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")) (_el-out (dom-create-element "div")))
(dom-set-attr _el-button "_" "on click answer \"Save?\" with \"Yes\" or \"No\" then put it into #out")
(dom-set-inner-html _el-button "Go")
(dom-set-attr _el-out "id" "out")
(dom-append (dom-body) _el-button)
(dom-append (dom-body) _el-out)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "out")) "No")
))
(deftest "prompts and puts result in it"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")) (_el-out (dom-create-element "div")))
(dom-set-attr _el-button "_" "on click ask \"What is your name?\" then put it into #out")
(dom-set-inner-html _el-button "Ask")
(dom-set-attr _el-out "id" "out")
(dom-append (dom-body) _el-button)
(dom-append (dom-body) _el-out)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "out")) "Alice")
))
(deftest "returns null on cancel"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")) (_el-out (dom-create-element "div")))
(dom-set-attr _el-button "_" "on click ask \"Name?\" then put it into #out")
(dom-set-inner-html _el-button "Ask")
(dom-set-attr _el-out "id" "out")
(dom-append (dom-body) _el-button)
(dom-append (dom-body) _el-out)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "out")) "null")
))
(deftest "shows an alert"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")) (_el-out (dom-create-element "div")))
(dom-set-attr _el-button "_" "on click answer \"Hello!\" then put \"done\" into #out")
(dom-set-inner-html _el-button "Go")
(dom-set-attr _el-out "id" "out")
(dom-append (dom-body) _el-button)
(dom-append (dom-body) _el-out)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "out")) "done")
))
)
;; ── behavior (10 tests) ──
(defsuite "hs-upstream-behavior"
(deftest "can declare variables in init blocks"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave
init
set element's foo to 1
set element's bar to {}
end
on click
increment element's foo
set element's bar[\"count\"] to element's foo
put element's bar[\"count\"] into me
end
end")
(dom-set-attr _el-div "_" "install Behave")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "2")
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "3")
))
(deftest "can define behaviors"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior TheBehaviorWeAreDefiningForHyperscriptTestingPurposes init log 'foo' end end")
(dom-append (dom-body) _el-script)
))
(deftest "can install behaviors"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave on click add .foo end end")
(dom-set-attr _el-div "_" "install Behave")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (dom-has-class? _el-div "foo"))
))
(deftest "can pass arguments to behaviors"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave(foo, bar) on click put foo + bar into me end end")
(dom-set-attr _el-div "_" "install Behave(foo: 1, bar: 1)")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "2")
))
(deftest "can pass element arguments to listen to in behaviors"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-b1 (dom-create-element "button")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave(elt) on click from elt put 'foo' into me end end")
(dom-set-attr _el-b1 "id" "b1")
(dom-set-attr _el-div "_" "install Behave(elt: #b1)")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-b1)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch (dom-query-by-id "b1") "click" nil)
(assert= (dom-text-content _el-div) "foo")
))
(deftest "can refer to arguments in init blocks"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-d1 (dom-create-element "div")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave(elt) init put 'foo' into elt end end")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-div "_" "install Behave(elt: #d1)")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-d1)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "install resolves namespaced behavior paths"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior App.Widgets.Clickable on click add .clicked end end")
(dom-set-attr _el-div "_" "install App.Widgets.Clickable")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (dom-has-class? _el-div "clicked"))
))
(deftest "install throws when the behavior path does not exist"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "install NoSuchBehavior")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "install throws when the path resolves to a non-function"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "install NotABehavior")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "supports init blocks in behaviors"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave init add .foo to me end")
(dom-set-attr _el-div "_" "install Behave")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
)
;; ── bind (44 tests) ──
(defsuite "hs-upstream-bind"
(deftest "\"with\" is a synonym for \"and\""
(hs-cleanup!)
(let ((_el-city-input (dom-create-element "input")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-city-input "id" "city-input")
(dom-set-attr _el-city-input "type" "text")
(dom-set-attr _el-city-input "value" "Paris")
(dom-set-attr _el-span "_" "bind $city to #city-input.value end when $city changes put it into me")
(dom-append (dom-body) _el-city-input)
(dom-append (dom-body) _el-span)
(hs-activate! _el-span)
))
(deftest "attribute bound to another element input value"
(hs-cleanup!)
(let ((_el-title-input (dom-create-element "input")) (_el-h1 (dom-create-element "h1")))
(dom-set-attr _el-title-input "id" "title-input")
(dom-set-attr _el-title-input "type" "text")
(dom-set-attr _el-title-input "value" "Hello")
(dom-set-attr _el-h1 "_" "bind @data-title and #title-input's value")
(dom-append (dom-body) _el-title-input)
(dom-append (dom-body) _el-h1)
(hs-activate! _el-h1)
(dom-set-prop (dom-query-by-id "title-input") "value" "World")
(dom-dispatch (dom-query-by-id "title-input") "input" nil)
))
(deftest "bind element to element: both sides auto-detect"
(hs-cleanup!)
(let ((_el-range-slider (dom-create-element "input")) (_el-input (dom-create-element "input")))
(dom-set-attr _el-range-slider "id" "range-slider")
(dom-set-attr _el-range-slider "type" "range")
(dom-set-attr _el-range-slider "value" "50")
(dom-set-attr _el-input "_" "bind me to #range-slider")
(dom-set-attr _el-input "type" "number")
(dom-append (dom-body) _el-range-slider)
(dom-append (dom-body) _el-input)
(hs-activate! _el-input)
))
(deftest "bind to contenteditable element auto-detects textContent"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind $text to me")
(dom-set-attr _el-div "contenteditable" "true")
(dom-set-inner-html _el-div "initial")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "bind to custom element with value property auto-detects value"
(hs-cleanup!)
(let ((_el-test-input (dom-create-element "test-input")))
(dom-set-attr _el-test-input "_" "bind $custom to me")
(dom-append (dom-body) _el-test-input)
(hs-activate! _el-test-input)
))
(deftest "bind variable to checkbox by id auto-detects checked"
(hs-cleanup!)
(let ((_el-agree-cb (dom-create-element "input")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-agree-cb "id" "agree-cb")
(dom-set-attr _el-agree-cb "type" "checkbox")
(dom-set-attr _el-div "_" "bind $agreed to #agree-cb")
(dom-append (dom-body) _el-agree-cb)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "bind variable to element by id auto-detects value"
(hs-cleanup!)
(let ((_el-name-field (dom-create-element "input")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-name-field "id" "name-field")
(dom-set-attr _el-name-field "type" "text")
(dom-set-attr _el-name-field "value" "")
(dom-set-attr _el-div "_" "bind $name to #name-field")
(dom-append (dom-body) _el-name-field)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "bind variable to number input by id auto-detects valueAsNumber"
(hs-cleanup!)
(let ((_el-qty-input (dom-create-element "input")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-qty-input "id" "qty-input")
(dom-set-attr _el-qty-input "type" "number")
(dom-set-attr _el-div "_" "bind $qty to #qty-input")
(dom-append (dom-body) _el-qty-input)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "boolean bind to aria-* attribute uses \"true\"/\"false\" strings"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind $isHidden and @aria-hidden")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "boolean bind to attribute uses presence/absence"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind $isEnabled and @data-active")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "class bound to another element checkbox"
(hs-cleanup!)
(let ((_el-dark-toggle (dom-create-element "input")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-dark-toggle "id" "dark-toggle")
(dom-set-attr _el-dark-toggle "type" "checkbox")
(dom-set-attr _el-div "_" "bind .dark and #dark-toggle's checked")
(dom-set-inner-html _el-div "test")
(dom-append (dom-body) _el-dark-toggle)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-set-prop (dom-query-by-id "dark-toggle") "checked" true)
(dom-dispatch (dom-query-by-id "dark-toggle") "change" nil)
(dom-set-prop (dom-query-by-id "dark-toggle") "checked" false)
(dom-dispatch (dom-query-by-id "dark-toggle") "change" nil)
))
(deftest "clicking a radio sets the variable to its value"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-input1 (dom-create-element "input")) (_el-input2 (dom-create-element "input")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-input "_" "bind $color to me")
(dom-set-attr _el-input "type" "radio")
(dom-set-attr _el-input "name" "color")
(dom-set-attr _el-input "value" "red")
(dom-set-attr _el-input1 "_" "bind $color to me")
(dom-set-attr _el-input1 "type" "radio")
(dom-set-attr _el-input1 "name" "color")
(dom-set-attr _el-input1 "value" "blue")
(dom-set-attr _el-input2 "_" "bind $color to me")
(dom-set-attr _el-input2 "type" "radio")
(dom-set-attr _el-input2 "name" "color")
(dom-set-attr _el-input2 "value" "green")
(dom-set-attr _el-span "_" "when $color changes put it into me")
(dom-append (dom-body) _el-input)
(dom-append (dom-body) _el-input1)
(dom-append (dom-body) _el-input2)
(dom-append (dom-body) _el-span)
(hs-activate! _el-input)
(hs-activate! _el-input1)
(hs-activate! _el-input2)
(hs-activate! _el-span)
(dom-dispatch (dom-query "input[value="blue"]") "click" nil)
(dom-dispatch (dom-query "input[value="green"]") "click" nil)
))
(deftest "dedup prevents infinite loop in two-way bind"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind $color and @data-color")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "external JS property write does not sync (known limitation)"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-input "_" "bind $searchTerm to me")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "original")
(dom-set-attr _el-span "_" "when $searchTerm changes put it into me")
(dom-append (dom-body) _el-input)
(dom-append (dom-body) _el-span)
(hs-activate! _el-input)
(hs-activate! _el-span)
))
(deftest "external class change syncs back to variable"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind .dark and $darkMode")
(dom-set-inner-html _el-div "test")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "form reset listener is removed on cleanup"
(hs-cleanup!)
(let ((_el-form (dom-create-element "form")) (_el-binput (dom-create-element "input")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-binput "id" "binput")
(dom-set-attr _el-binput "_" "bind $val to me")
(dom-set-attr _el-binput "type" "text")
(dom-set-attr _el-binput "value" "initial")
(dom-set-attr _el-button "type" "reset")
(dom-set-inner-html _el-button "Reset")
(dom-append (dom-body) _el-form)
(dom-append _el-form _el-binput)
(dom-append _el-form _el-button)
(hs-activate! _el-binput)
))
(deftest "form.reset() syncs variable back to default value"
(hs-cleanup!)
(let ((_el-test-form (dom-create-element "form")) (_el-input (dom-create-element "input")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-test-form "id" "test-form")
(dom-set-attr _el-input "_" "bind $formField to me")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "default")
(dom-set-attr _el-span "_" "when $formField changes put it into me")
(dom-append (dom-body) _el-test-form)
(dom-append _el-test-form _el-input)
(dom-append (dom-body) _el-span)
(hs-activate! _el-input)
(hs-activate! _el-span)
(dom-set-prop _el-input "value" "user typed this")
(dom-dispatch _el-input "input" nil)
))
(deftest "init: right side wins - attribute (Y) initializes variable (X)"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind $color to @data-color")
(dom-set-attr _el-div "data-color" "red")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "init: right side wins - class (Y) drives variable (X)"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "dark")
(dom-set-attr _el-div "_" "bind $isDark to .dark")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "init: right side wins - input value (Y) overwrites variable (X)"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind $name to my value")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "Bob")
(dom-append (dom-body) _el-input)
(hs-activate! _el-input)
))
(deftest "init: right side wins - variable (Y) drives class (X)"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind .dark to $isDark")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "init: right side wins - variable (Y) initializes attribute (X)"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind @data-theme to $theme")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "init: right side wins - variable (Y) overwrites input value (X)"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind my value to $name")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "Bob")
(dom-append (dom-body) _el-input)
(hs-activate! _el-input)
))
(deftest "initial value checks the correct radio on load"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-input1 (dom-create-element "input")) (_el-input2 (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind $fruit to me")
(dom-set-attr _el-input "type" "radio")
(dom-set-attr _el-input "name" "fruit")
(dom-set-attr _el-input "value" "apple")
(dom-set-attr _el-input1 "_" "bind $fruit to me")
(dom-set-attr _el-input1 "type" "radio")
(dom-set-attr _el-input1 "name" "fruit")
(dom-set-attr _el-input1 "value" "banana")
(dom-set-attr _el-input2 "_" "bind $fruit to me")
(dom-set-attr _el-input2 "type" "radio")
(dom-set-attr _el-input2 "name" "fruit")
(dom-set-attr _el-input2 "value" "cherry")
(dom-append (dom-body) _el-input)
(dom-append (dom-body) _el-input1)
(dom-append (dom-body) _el-input2)
(hs-activate! _el-input)
(hs-activate! _el-input1)
(hs-activate! _el-input2)
))
(deftest "of-expression: bind $var to value of #input"
(hs-cleanup!)
(let ((_el-of-input (dom-create-element "input")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-of-input "id" "of-input")
(dom-set-attr _el-of-input "type" "text")
(dom-set-attr _el-of-input "value" "initial")
(dom-set-attr _el-div "_" "bind $search to value of #of-input")
(dom-append (dom-body) _el-of-input)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "possessive attribute: bind $var and my @data-label"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind $label and my @data-label")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "possessive property: bind $var to my value"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind $myVal to my value")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "hello")
(dom-append (dom-body) _el-input)
(hs-activate! _el-input)
(dom-set-prop _el-input "value" "world")
(dom-dispatch _el-input "input" nil)
))
(deftest "radio change listener is removed on cleanup"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-input1 (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind $color to me")
(dom-set-attr _el-input "type" "radio")
(dom-set-attr _el-input "name" "color")
(dom-set-attr _el-input "value" "red")
(dom-set-attr _el-input "checked" "")
(dom-set-attr _el-input1 "_" "bind $color to me")
(dom-set-attr _el-input1 "type" "radio")
(dom-set-attr _el-input1 "name" "color")
(dom-set-attr _el-input1 "value" "blue")
(dom-append (dom-body) _el-input)
(dom-append (dom-body) _el-input1)
(hs-activate! _el-input)
(hs-activate! _el-input1)
))
(deftest "right side wins on class init"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "bind .highlight to $highlighted")
(dom-set-inner-html _el-div "test")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "right side wins on init: input (Y) initializes variable (X)"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind $name to me")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "Bob")
(dom-append (dom-body) _el-input)
(hs-activate! _el-input)
))
(deftest "right side wins on init: variable (Y) initializes input (X)"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind me to $name")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "Bob")
(dom-append (dom-body) _el-input)
(hs-activate! _el-input)
))
(deftest "same value does not re-set input (prevents cursor jump)"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind $message to me")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-input "value" "hello")
(dom-append (dom-body) _el-input)
(hs-activate! _el-input)
))
(deftest "setting variable programmatically checks the matching radio"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-input1 (dom-create-element "input")) (_el-input2 (dom-create-element "input")))
(dom-set-attr _el-input "_" "bind $size to me")
(dom-set-attr _el-input "type" "radio")
(dom-set-attr _el-input "name" "size")
(dom-set-attr _el-input "value" "small")
(dom-set-attr _el-input1 "_" "bind $size to me")
(dom-set-attr _el-input1 "type" "radio")
(dom-set-attr _el-input1 "name" "size")
(dom-set-attr _el-input1 "value" "medium")
(dom-set-attr _el-input2 "_" "bind $size to me")
(dom-set-attr _el-input2 "type" "radio")
(dom-set-attr _el-input2 "name" "size")
(dom-set-attr _el-input2 "value" "large")
(dom-append (dom-body) _el-input)
(dom-append (dom-body) _el-input1)
(dom-append (dom-body) _el-input2)
(hs-activate! _el-input)
(hs-activate! _el-input1)
(hs-activate! _el-input2)
))
(deftest "shorthand on checkbox binds to checked"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-input "_" "bind $isDarkMode to me")
(dom-set-attr _el-input "type" "checkbox")
(dom-set-attr _el-span "_" "when $isDarkMode changes put it into me")
(dom-append (dom-body) _el-input)
(dom-append (dom-body) _el-span)
(hs-activate! _el-input)
(hs-activate! _el-span)
(dom-set-prop _el-input "checked" true)
(dom-dispatch _el-input "change" nil)
))
(deftest "shorthand on select binds to value"
(hs-cleanup!)
(let ((_el-select (dom-create-element "select")) (_el-option (dom-create-element "option")) (_el-option2 (dom-create-element "option")) (_el-option3 (dom-create-element "option")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-select "_" "bind $country to me")
(dom-set-attr _el-option "value" "us")
(dom-set-inner-html _el-option "United States")
(dom-set-attr _el-option2 "value" "uk")
(dom-set-inner-html _el-option2 "United Kingdom")
(dom-set-attr _el-option3 "value" "fr")
(dom-set-inner-html _el-option3 "France")
(dom-set-attr _el-span "_" "when $country changes put it into me")
(dom-append (dom-body) _el-select)
(dom-append _el-select _el-option)
(dom-append _el-select _el-option2)
(dom-append _el-select _el-option3)
(dom-append (dom-body) _el-span)
(hs-activate! _el-select)
(hs-activate! _el-span)
(dom-set-prop _el-select "value" "uk")
(dom-dispatch _el-select "change" nil)
))
(deftest "shorthand on text input binds to value"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-input "_" "bind $greeting to me end when $greeting changes put it into next ${}{^msg} ")
(dom-append (dom-body) _el-script)
(hs-activate! _el-script)
))
(deftest "loop index variable is captured alongside loop variable"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "
#for item in $idxItems index i
${}{item}
#end
")
(dom-append (dom-body) _el-script)
))
(deftest "loop variable capture works with remove for live list"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "
#for item in $removeItems
${}{item.name} x ")
(dom-append (dom-body) _el-script)
(dom-dispatch (dom-query "[data-live-template] li').nth(1).locator('button") "click" nil)
(assert= (dom-text-content (dom-query "[data-live-template] li').first().locator('span")) "A")
(assert= (dom-text-content (dom-query "[data-live-template] li').last().locator('span")) "C")
))
(deftest "loop variables are captured and available in _= handlers"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "
#for item in $captureItems index i
${}{item.name}
#end
")
(dom-append (dom-body) _el-script)
))
(deftest "multiple live templates are independent"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-script1 (dom-create-element "script")))
(dom-set-attr _el-script "_" "init set ^x to 'first'")
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "${}{^x} ")
(dom-set-attr _el-script1 "_" "init set ^x to 'second'")
(dom-set-attr _el-script1 "type" "text/hyperscript-template")
(dom-set-inner-html _el-script1 "${}{^x} ")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-script1)
(hs-activate! _el-script)
(hs-activate! _el-script1)
))
(deftest "processes hyperscript on inner elements"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "_" "init set ^val to 0")
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "0 ")
(dom-append (dom-body) _el-script)
(hs-activate! _el-script)
(dom-dispatch (dom-query "[data-live-template] button") "click" nil)
))
(deftest "reactively updates when dependencies change"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "_" "init set ^count to 0")
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "+
Count: ${}{^count} ")
(dom-append (dom-body) _el-script)
(hs-activate! _el-script)
(dom-dispatch (dom-query "[data-live-template] button") "click" nil)
))
(deftest "reacts to global state without init script"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "Hello, ${}{$ltGlobal}!
")
(dom-append (dom-body) _el-script)
))
(deftest "renders static content after the template"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "Hello World ")
(dom-append (dom-body) _el-script)
))
(deftest "renders template expressions"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "Hello ${}{$ltName}! ")
(dom-append (dom-body) _el-script)
))
(deftest "scope is refreshed after morph so surviving elements get updated indices"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "
#for item in $morphItems index i
${}{item.name}
#end
")
(dom-append (dom-body) _el-script)
(dom-dispatch (dom-query "[data-live-template] li") "click" nil)
(assert= (dom-text-content (dom-query "[data-live-template] li")) "2:C")
(dom-dispatch (dom-query "[data-live-template] li") "click" nil)
(assert= (dom-text-content (dom-query "[data-live-template] li")) "1:C")
))
(deftest "script type=\"text/hyperscript-template\" works as a live template source"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "_" "init set ^stMsg to 'from script'")
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "${}{^stMsg} ")
(dom-append (dom-body) _el-script)
(hs-activate! _el-script)
))
(deftest "script-based live template preserves ${} in bare attribute position"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "_" "init set ^items to [{text:'A', done:true},{text:'B', done:false}]")
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "")
(dom-append (dom-body) _el-script)
(hs-activate! _el-script)
))
(deftest "supports #for loops"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "_" "init set ^items to ['a', 'b', 'c']")
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "
#for item in ^items
${}{item}
#end
")
(dom-append (dom-body) _el-script)
(hs-activate! _el-script)
))
(deftest "supports #if conditionals"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "_" "init set ^show to true")
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "#if ^show
visible
#end")
(dom-append (dom-body) _el-script)
(hs-activate! _el-script)
))
(deftest "wrapper has display:contents"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")))
(dom-set-attr _el-script "type" "text/hyperscript-template")
(dom-set-inner-html _el-script "test ")
(dom-append (dom-body) _el-script)
))
)
;; ── core/parser (14 tests) ──
(defsuite "hs-upstream-core/parser"
(deftest "_hyperscript() evaluate API still throws on first error"
(error "SKIP (untranslated): _hyperscript() evaluate API still throws on first error"))
(deftest "basic parse error messages work"
(error "SKIP (untranslated): basic parse error messages work"))
(deftest "can have alternate comments in attributes"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click put \"clicked\" into my.innerHTML // put some content into the div...")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "clicked")
))
(deftest "can have alternate comments in scripts"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "// this is a comment def foo() // this is another comment return \"foo\" end // end with a comment"))))
)
(deftest "can have comments in attributes"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click put \"clicked\" into my.innerHTML -- put some content into the div...")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "clicked")
))
(deftest "can have comments in attributes (triple dash)"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click put \"clicked\" into my.innerHTML ---put some content into the div...")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "clicked")
))
(deftest "can have comments in scripts"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "-- this is a comment def foo() -- this is another comment return \"foo\" end -- end with a comment--- this is a comment ----this is a comment---- def bar() ---this is another comment return \"bar\" end --- end with a comment"))))
)
(deftest "can support parenthesized commands and features"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "(on click (log me) (trigger foo)) (on foo (put \"clicked\" into my.innerHTML))")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "clicked")
))
(deftest "continues initializing elements in the presence of a parse error"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click bad")
(dom-set-attr _el-d2 "id" "d2")
(dom-set-attr _el-d2 "_" "on click put \"clicked\" into my.innerHTML")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-d1)
(dom-append _el-div _el-d2)
(hs-activate! _el-d1)
(hs-activate! _el-d2)
(dom-dispatch (dom-query-by-id "d2") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d2")) "clicked")
))
(deftest "element-level isolation still works with error recovery"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click blargh end on mouseenter also_bad")
(dom-set-attr _el-d2 "id" "d2")
(dom-set-attr _el-d2 "_" "on click put \"clicked\" into my.innerHTML")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-d1)
(dom-append _el-div _el-d2)
(hs-activate! _el-d1)
(hs-activate! _el-d2)
(dom-dispatch (dom-query-by-id "d2") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d2")) "clicked")
))
(deftest "fires hyperscript:parse-error event with all errors"
(error "SKIP (untranslated): fires hyperscript:parse-error event with all errors"))
(deftest "parse error at EOF on trailing newline does not crash"
(error "SKIP (untranslated): parse error at EOF on trailing newline does not crash"))
(deftest "recovers across feature boundaries and reports all errors"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click blargh end on mouseenter put \"hovered\" into my.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
))
(deftest "recovers across multiple feature errors"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click blargh end on mouseenter also_bad end on focus put \"focused\" into my.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
))
)
;; ── core/reactivity (8 tests) ──
(defsuite "hs-upstream-core/reactivity"
(deftest "NaN → NaN does not retrigger handlers (Object.is semantics)"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "when $rxNanVal changes increment $rxNanCount")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "effect switches its dependencies based on control flow"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "live if $rxCond put $rxA into me else put $rxB into me end end")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "effects fire in source registration order"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-div1 (dom-create-element "div")) (_el-div2 (dom-create-element "div")))
(dom-set-attr _el-div "_" "when $rxTrigger changes call $rxOrder.push('first')")
(dom-set-attr _el-div1 "_" "when $rxTrigger changes call $rxOrder.push('second')")
(dom-set-attr _el-div2 "_" "when $rxTrigger changes call $rxOrder.push('third')")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-div1)
(dom-append (dom-body) _el-div2)
(hs-activate! _el-div)
(hs-activate! _el-div1)
(hs-activate! _el-div2)
))
(deftest "effects on disconnected elements stop automatically"
(hs-cleanup!)
(let ((_el-persist (dom-create-element "div")) (_el-doomed (dom-create-element "div")))
(dom-set-attr _el-persist "id" "persist")
(dom-set-attr _el-persist "_" "when $rxDcVal changes increment $rxDcCount then put $rxDcVal into me")
(dom-set-attr _el-doomed "id" "doomed")
(dom-set-attr _el-doomed "_" "when $rxDcVal changes increment $rxDcCount")
(dom-append (dom-body) _el-persist)
(dom-append (dom-body) _el-doomed)
(hs-activate! _el-persist)
(hs-activate! _el-doomed)
))
(deftest "element-scoped writes only trigger effects on the same element"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-b (dom-create-element "div")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-a "_" "init set :count to 0 then on click increment :count then when :count changes put :count into me")
(dom-set-attr _el-b "id" "b")
(dom-set-attr _el-b "_" "init set :count to 0 then when :count changes put :count into me")
(dom-append (dom-body) _el-a)
(dom-append (dom-body) _el-b)
(hs-activate! _el-a)
(hs-activate! _el-b)
(dom-dispatch (dom-query-by-id "a") "click" nil)
(assert= (dom-text-content (dom-query-by-id "a")) "1")
(assert= (dom-text-content (dom-query-by-id "b")) "0")
))
(deftest "multiple effects on the same global fire once per write"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-b (dom-create-element "div")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-a "_" "when $rxVal changes increment $rxCount then put $rxVal into me")
(dom-set-attr _el-b "id" "b")
(dom-set-attr _el-b "_" "when $rxVal changes put $rxVal into me")
(dom-append (dom-body) _el-a)
(dom-append (dom-body) _el-b)
(hs-activate! _el-a)
(hs-activate! _el-b)
))
(deftest "reactive loops are detected and stopped after 100 consecutive triggers"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "when $rxLoop changes increment $rxLoop")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "setting same value does not retrigger handler"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "when $rxSameVal changes increment $rxSameCount")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
)
;; ── core/regressions (16 tests) ──
(defsuite "hs-upstream-core/regressions"
(deftest "async exception"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click async transition opacity to 0 log \"hello!\"")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
))
(deftest "button query in form"
(hs-cleanup!)
(let ((_el-form (dom-create-element "form")) (_el-b1 (dom-create-element "button")))
(dom-set-attr _el-form "_" "on click get the
then put #i1.value into its textContent put it.outerHTML at end of #d2")
(dom-append (dom-body) _el-i1)
(dom-append _el-i1 _el-d2)
(dom-append _el-i1 _el-div)
(hs-activate! _el-div)
(dom-dispatch (dom-query "div:nth-of-type(2)") "click" nil)
))
(deftest "can invoke functions w/ numbers in name"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")))
(dom-set-attr _el-button "_" "on click put select2() into me")
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content _el-button) "select2")
))
(deftest "can pick detail fields out by name"
(error "SKIP (skip-list): can pick detail fields out by name"))
(deftest "can refer to function in init blocks"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-d1)
))
(deftest "can remove by clicks elsewhere"
(hs-cleanup!)
(let ((_el-target (dom-create-element "div")) (_el-other (dom-create-element "div")))
(dom-set-attr _el-target "id" "target")
(dom-set-attr _el-target "_" "on click elsewhere remove me")
(dom-set-attr _el-other "id" "other")
(dom-append (dom-body) _el-target)
(dom-append (dom-body) _el-other)
(hs-activate! _el-target)
))
(deftest "can remove class by id"
(hs-cleanup!)
(let ((_el-email-form (dom-create-element "form")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-email-form "id" "email-form")
(dom-add-class _el-email-form "hideme")
(dom-set-attr _el-div "_" "on click remove .hideme from #email-form")
(dom-append (dom-body) _el-email-form)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (not (dom-has-class? (dom-query-by-id "email-form") "hideme")))
))
(deftest "can trigger htmx events"
(hs-cleanup!)
(let ((_el-div1 (dom-create-element "div")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-div1 "id" "div1")
(dom-set-attr _el-div1 "_" "on htmx:foo put \"foo\" into my.innerHTML")
(dom-set-attr _el-div "_" "on click send htmx:foo to #div1")
(dom-append (dom-body) _el-div1)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div1)
(hs-activate! _el-div)
(dom-dispatch (dom-query "div:nth-of-type(2)") "click" nil)
(assert= (dom-text-content (dom-query-by-id "div1")) "foo")
))
(deftest "extra chars cause error when evaling"
(error "SKIP (untranslated): extra chars cause error when evaling"))
(deftest "listen for event on form"
(hs-cleanup!)
(let ((_el-form (dom-create-element "form")) (_el-b1 (dom-create-element "button")))
(dom-set-attr _el-b1 "id" "b1")
(dom-set-attr _el-b1 "_" "on click from closest put \"clicked\" into me")
(dom-set-inner-html _el-b1 "Button")
(dom-append (dom-body) _el-form)
(dom-append _el-form _el-b1)
(hs-activate! _el-b1)
(dom-dispatch _el-form "click" nil)
(assert= (dom-text-content (dom-query-by-id "b1")) "clicked")
))
(deftest "me and it is properly set when responding to events"
(hs-cleanup!)
(let ((_el-name (dom-create-element "div")) (_el-div (dom-create-element "div")))
(dom-set-attr _el-name "id" "name")
(dom-set-attr _el-div "_" "on click from #name set window.me to me set window.it to it")
(dom-append (dom-body) _el-name)
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch (dom-query-by-id "name") "click" nil)
))
(deftest "me symbol works in from expressions"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click from closest parent
put \"Foo\" into me")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-d1)
(hs-activate! _el-d1)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "Foo")
))
(deftest "properly interpolates values"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")))
(dom-set-attr _el-button "_" "on click set count to 1 then set optName to `options_${count}_value` then put optName into me")
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content _el-button) "options_1_value")
))
(deftest "properly interpolates values 2"
(hs-cleanup!)
(let ((_el-button (dom-create-element "button")))
(dom-set-attr _el-button "_" "on click set trackingcode to `AB123456789KK` then set pdfurl to `https://yyy.xxxxxx.com/path/out/${trackingcode}.pdf` then put pdfurl into me")
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content _el-button) "https://yyy.xxxxxx.com/path/out/AB123456789KK.pdf")
))
(deftest "string literals can dot-invoked against"
(assert= (eval-hs "'foo'.length") 3)
(assert= (eval-hs "`foo`.length") 3)
(assert= (eval-hs "\"foo\".length") 3)
)
)
;; ── core/runtime (7 tests) ──
(defsuite "hs-upstream-core/runtime"
(deftest "arrays args are handled properly wrt Promises"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def invokesArrayPromise() return { foo: stringPromise(), bar: stringPromise(), baz: stringPromise() }end def stringPromise() wait 20ms return 'foo' end"))))
)
(deftest "async hypertrace is reasonable"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call bar()")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
))
(deftest "has proper stack"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() return bar() end def bar() return meta.caller end"))))
)
(deftest "has proper stack from event handler"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click put bar().meta.feature.type into my.innerHTML")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "onFeature")
))
(deftest "hypertrace from javascript is reasonable"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call bar()")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
))
(deftest "hypertrace is reasonable"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call bar()")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
))
(deftest "scalar args are handled properly wrt Promises"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def invokesScalarPromise() return stringPromise()end def stringPromise() wait 20ms return 'foo' end"))))
)
)
;; ── core/runtimeErrors (18 tests) ──
(defsuite "hs-upstream-core/runtimeErrors"
(deftest "reports basic function invocation null errors properly"
(error "SKIP (untranslated): reports basic function invocation null errors properly"))
(deftest "reports basic function invocation null errors properly w/ of"
(error "SKIP (untranslated): reports basic function invocation null errors properly w/ of"))
(deftest "reports basic function invocation null errors properly w/ possessives"
(error "SKIP (untranslated): reports basic function invocation null errors properly w/ possessives"))
(deftest "reports null errors on add command properly"
(error "SKIP (untranslated): reports null errors on add command properly"))
(deftest "reports null errors on decrement command properly"
(error "SKIP (untranslated): reports null errors on decrement command properly"))
(deftest "reports null errors on default command properly"
(error "SKIP (untranslated): reports null errors on default command properly"))
(deftest "reports null errors on hide command properly"
(error "SKIP (untranslated): reports null errors on hide command properly"))
(deftest "reports null errors on increment command properly"
(error "SKIP (untranslated): reports null errors on increment command properly"))
(deftest "reports null errors on measure command properly"
(error "SKIP (untranslated): reports null errors on measure command properly"))
(deftest "reports null errors on put command properly"
(error "SKIP (untranslated): reports null errors on put command properly"))
(deftest "reports null errors on remove command properly"
(error "SKIP (untranslated): reports null errors on remove command properly"))
(deftest "reports null errors on send command properly"
(error "SKIP (untranslated): reports null errors on send command properly"))
(deftest "reports null errors on sets properly"
(error "SKIP (untranslated): reports null errors on sets properly"))
(deftest "reports null errors on settle command properly"
(error "SKIP (untranslated): reports null errors on settle command properly"))
(deftest "reports null errors on show command properly"
(error "SKIP (untranslated): reports null errors on show command properly"))
(deftest "reports null errors on toggle command properly"
(error "SKIP (untranslated): reports null errors on toggle command properly"))
(deftest "reports null errors on transition command properly"
(error "SKIP (untranslated): reports null errors on transition command properly"))
(deftest "reports null errors on trigger command properly"
(error "SKIP (untranslated): reports null errors on trigger command properly"))
)
;; ── core/scoping (20 tests) ──
(defsuite "hs-upstream-core/scoping"
(deftest "basic behavior scoping works"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave(foo) on click set @out to foo")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "install Behave(foo:10)")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "behavior scoping is at the element level"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave(foo) on click 1 set foo to foo + 10 on click 2 set @out to foo")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "install Behave(foo:10)")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "20")
))
(deftest "behavior scoping is isolated from other behaviors"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave(foo) on click 1 set foo to foo + 10 on click 3 set @out to foo behavior BehaveTwo(foo) on click 2 set element foo to 1 on click 4 set @out2 to foo")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "install Behave(foo:10) install BehaveTwo(foo:42)")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "20")
(assert= (dom-get-attr (dom-query-by-id "d1") "out2") "1")
))
(deftest "behavior scoping is isolated from the core element scope"
(hs-cleanup!)
(let ((_el-script (dom-create-element "script")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-script "type" "text/hyperscript")
(dom-set-inner-html _el-script "behavior Behave(foo) on click 1 set foo to foo + 10 on click 3 set @out to foo")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "install Behave(foo:10) on click 2 set element foo to 1 on click 4 set @out2 to foo")
(dom-append (dom-body) _el-script)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "20")
(assert= (dom-get-attr (dom-query-by-id "d1") "out2") "1")
))
(deftest "element scoped variables are local only to element"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set element x to 10")
(dom-set-attr _el-d2 "id" "d2")
(dom-set-attr _el-d2 "_" "on click set @out to x")
(dom-append (dom-body) _el-d1)
(dom-append _el-d1 _el-d2)
(hs-activate! _el-d1)
(hs-activate! _el-d2)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d2") "click" nil)
))
(deftest "element scoped variables span features"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click 1 set element x to 10 on click 2 set @out to x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "element scoped variables span features w/short syntax"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click 1 set :x to 10 on click 2 set @out to :x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "element scoped variables support pseudo-possessive syntax"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set the element's x to 10 then set @out to the element's x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "element scoped variables work"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set element x to 10 then set @out to x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "element scoped variables work w/short syntax"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set :x to 10 then set @out to :x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "global scoped variables span features"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click 1 set $x to 10 on click 2 set @out to $x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "global scoped variables work"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set global x to 10 then set @out to x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "global scoped variables work w/ short syntax"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set $x to 10 then set @out to $x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "locally scoped variables do not span features"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click 1 set x to 10 on click 2 set @out to x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
))
(deftest "locally scoped variables don't clash with built-in variables"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click repeat for meta in [1, 2, 3] set @out to meta end")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "[object Object]")
))
(deftest "locally scoped variables work"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set x to 10 then set @out to x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "set favors local variables over global variables"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click 1 set foo to 20 then set @out to foo")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "20")
))
(deftest "setting a global scoped variable spans features"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click 1 default global x to 0 on click 2 set global x to 10 on click 3 set @out to x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "setting an element scoped variable spans features"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click 1 default element x to 0 on click 2 set element x to 10 on click 3 set @out to x")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
(deftest "variables are hoisted"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click if true set foo to 10 end set @out to foo")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-get-attr (dom-query-by-id "d1") "out") "10")
))
)
;; ── core/security (1 tests) ──
(defsuite "hs-upstream-core/security"
(deftest "on a single div"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click add .foo")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert (not (dom-has-class? (dom-query-by-id "d1") "foo")))
))
)
;; ── core/sourceInfo (4 tests) ──
(defsuite "hs-upstream-core/sourceInfo"
(deftest "debug"
(error "SKIP (untranslated): debug"))
(deftest "get line works for statements"
(error "SKIP (untranslated): get line works for statements"))
(deftest "get source works for expressions"
(error "SKIP (untranslated): get source works for expressions"))
(deftest "get source works for statements"
(error "SKIP (untranslated): get source works for statements"))
)
;; ── core/tokenizer (17 tests) ──
(defsuite "hs-upstream-core/tokenizer"
(deftest "handles $ in template properly"
(error "SKIP (untranslated): handles $ in template properly"))
(deftest "handles all special escapes properly"
(error "SKIP (untranslated): handles all special escapes properly"))
(deftest "handles basic token types"
(error "SKIP (untranslated): handles basic token types"))
(deftest "handles class identifiers properly"
(error "SKIP (untranslated): handles class identifiers properly"))
(deftest "handles comments properly"
(error "SKIP (untranslated): handles comments properly"))
(deftest "handles hex escapes properly"
(error "SKIP (untranslated): handles hex escapes properly"))
(deftest "handles id references properly"
(error "SKIP (untranslated): handles id references properly"))
(deftest "handles identifiers properly"
(error "SKIP (untranslated): handles identifiers properly"))
(deftest "handles identifiers with numbers properly"
(error "SKIP (untranslated): handles identifiers with numbers properly"))
(deftest "handles look ahead property"
(error "SKIP (untranslated): handles look ahead property"))
(deftest "handles numbers properly"
(error "SKIP (untranslated): handles numbers properly"))
(deftest "handles operators properly"
(error "SKIP (untranslated): handles operators properly"))
(deftest "handles strings properly"
(error "SKIP (untranslated): handles strings properly"))
(deftest "handles strings properly 2"
(error "SKIP (untranslated): handles strings properly 2"))
(deftest "handles template bootstrap properly"
(error "SKIP (untranslated): handles template bootstrap properly"))
(deftest "handles whitespace properly"
(error "SKIP (untranslated): handles whitespace properly"))
(deftest "string interpolation isnt surprising"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set x to 42 then put `test${x} test ${x} test$x test $x test $x test ${x} test$x test_$x test_${x} test-$x test.$x` into my.innerHTML")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "test${x} test 42 test$x test 42 test $x test ${x} test42 test_42 test_42 test-42 test.42")
))
)
;; ── def (27 tests) ──
(defsuite "hs-upstream-def"
(deftest "async finally blocks run normally"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait a tick then set window.bar to 10 finally set window.bar to 20 end"))))
)
(deftest "async finally blocks run when an exception occurs"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait a tick then set window.bar to 10 throw \"foo\" finally set window.bar to 20 end"))))
)
(deftest "can call asynchronously"
(error "SKIP (skip-list): can call asynchronously"))
(deftest "can catch async exceptions"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def doh() wait 10ms throw \"bar\" end def foo() call doh() catch e set window.bar to e end"))))
)
(deftest "can catch exceptions"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() throw \"bar\" catch e set window.bar to e end"))))
)
(deftest "can catch nested async exceptions"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def doh() wait 10ms throw \"bar\" end def foo() call doh() catch e set window.bar to e end"))))
)
(deftest "can define a basic no arg function"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call foo()")
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert (dom-has-class? (dom-query-by-id "d1") "called"))
))
(deftest "can define a basic one arg function"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call foo(\"called\")")
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "called")
))
(deftest "can exit"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() exit end"))))
)
(deftest "can install a function on an element and use in children w/ no leak"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")) (_el-d3 (dom-create-element "div")))
(dom-set-attr _el-div "_" "def func() put 42 into #d3")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click call func()")
(dom-set-attr _el-d2 "id" "d2")
(dom-set-attr _el-d3 "id" "d3")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-d1)
(dom-append _el-div _el-d2)
(dom-append _el-div _el-d3)
(hs-activate! _el-div)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d3")) "42")
))
(deftest "can install a function on an element and use in children w/ return value"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")) (_el-d3 (dom-create-element "div")))
(dom-set-attr _el-div "_" "def func() return 42")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click put func() into me")
(dom-set-attr _el-d2 "id" "d2")
(dom-set-attr _el-d3 "id" "d3")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-d1)
(dom-append _el-div _el-d2)
(dom-append _el-div _el-d3)
(hs-activate! _el-div)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "42")
))
(deftest "can install a function on an element and use me symbol correctly"
(hs-cleanup!)
(let ((_el-outer (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")) (_el-d3 (dom-create-element "div")))
(dom-set-attr _el-outer "id" "outer")
(dom-set-attr _el-outer "_" "def func() put 42 into me")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click call func()")
(dom-set-attr _el-d2 "id" "d2")
(dom-set-attr _el-d3 "id" "d3")
(dom-append (dom-body) _el-outer)
(dom-append _el-outer _el-d1)
(dom-append _el-outer _el-d2)
(dom-append _el-outer _el-d3)
(hs-activate! _el-outer)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "outer")) "42")
))
(deftest "can interop with javascript"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() return \"foo\" end"))))
)
(deftest "can interop with javascript asynchronously"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() wait 1ms return \"foo\" end"))))
)
(deftest "can rethrow in async catch blocks"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() throw \"bar\" catch e wait 10ms throw e end"))))
)
(deftest "can rethrow in catch blocks"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() throw \"bar\" catch e throw e end"))))
)
(deftest "can return a value asynchronously"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call foo() then put it into #d1.innerText")
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "foo")
))
(deftest "can return a value synchronously"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click call foo() then put it into #d1.innerText")
(dom-set-attr _el-d1 "id" "d1")
(dom-append (dom-body) _el-div)
(dom-append (dom-body) _el-d1)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "foo")
))
(deftest "can return in async catch blocks"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() throw \"bar\" catch e wait 10ms return 42 end"))))
)
(deftest "can return in catch blocks"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() throw \"bar\" catch e return 42 end"))))
)
(deftest "can return without a value"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() return end"))))
)
(deftest "exit stops execution mid-function"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() set x to 1 then exit then set x to 2 then return x end"))))
)
(deftest "finally blocks run normally"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() set window.bar to 10 finally set window.bar to 20 end"))))
)
(deftest "finally blocks run when an exception expr occurs"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() set window.bar to 10 call throwsAsyncException() finally set window.bar to 20 end"))))
)
(deftest "finally blocks run when an exception occurs"
(hs-cleanup!)
(guard (_e (true nil)) (eval-expr-cek (hs-to-sx (hs-compile "def foo() set window.bar to 10 throw \"foo\" finally set window.bar to 20 end"))))
)
(deftest "functions can be namespaced"
(error "SKIP (skip-list): functions can be namespaced"))
(deftest "is called synchronously"
(error "SKIP (skip-list): is called synchronously"))
)
;; ── default (15 tests) ──
(defsuite "hs-upstream-default"
(deftest "can default array elements"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set arr to [null, null] then default arr[0] to 'yes' then put arr[0] into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "yes")
))
(deftest "can default attributes"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click default @foo to \"foo\" then put @foo into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "foo")
))
(deftest "can default of-expression properties"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click default foo of me to 'bar' then put my foo into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "bar")
))
(deftest "can default possessive properties"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click default #d1's foo to 'bar' then put #d1's foo into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "bar")
))
(deftest "can default properties"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click default me.foo to \"foo\" then put me.foo into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "foo")
))
(deftest "can default style ref when unset"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click default *background-color to 'red'")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-get-style _el-div "background-color") "")
))
(deftest "can default variables"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click default x to \"foo\" then put x into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "foo")
))
(deftest "default array element respects existing value"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set arr to ['existing', null] then default arr[0] to 'new' then put arr[0] into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "existing")
))
(deftest "default attributes respect existing values"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click default @foo to \"foo\" then put @foo into me")
(dom-set-attr _el-d1 "foo" "bar")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "bar")
))
(deftest "default overwrites empty string"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set x to \"\" then default x to \"fallback\" then put x into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "fallback")
))
(deftest "default preserves false"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set x to false then default x to true then put x into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "false")
))
(deftest "default preserves zero"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set x to 0 then default x to 10 then put x into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "0")
))
(deftest "default properties respect existing values"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set me.foo to \"bar\" then default me.foo to \"foo\" then put me.foo into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "bar")
))
(deftest "default style ref preserves existing value"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click default *color to 'red'")
(dom-set-attr _el-div "style" "color: blue")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-get-style _el-div "color") "")
))
(deftest "default variables respect existing values"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set x to \"bar\" then default x to \"foo\" then put x into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "bar")
))
)
;; ── dialog (12 tests) ──
(defsuite "hs-upstream-dialog"
(deftest "close closes a details element"
(hs-cleanup!)
(let ((_el-d (dom-create-element "details")) (_el-summary (dom-create-element "summary")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-attr _el-d "open" "")
(dom-set-inner-html _el-summary "More")
(dom-set-inner-html _el-p "Content")
(dom-set-attr _el-button "_" "on click close #d")
(dom-set-inner-html _el-button "Close")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-summary)
(dom-append _el-d _el-p)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert (not (dom-has-attr? (dom-query-by-id "d") "open")))
))
(deftest "close closes a dialog"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-p (dom-create-element "p")) (_el-close (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-p "Hello")
(dom-set-attr _el-close "id" "close")
(dom-set-attr _el-close "_" "on click close #d")
(dom-set-inner-html _el-close "Close")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-p)
(dom-append _el-d _el-close)
(hs-activate! _el-close)
(dom-dispatch (dom-query-by-id "close") "click" nil)
(assert (not (dom-has-attr? (dom-query-by-id "d") "open")))
))
(deftest "close hides a popover"
(hs-cleanup!)
(let ((_el-p (dom-create-element "div")) (_el-p1 (dom-create-element "p")) (_el-close (dom-create-element "button")))
(dom-set-attr _el-p "id" "p")
(dom-set-inner-html _el-p1 "Popover content")
(dom-set-attr _el-close "id" "close")
(dom-set-attr _el-close "_" "on click close #p")
(dom-set-inner-html _el-close "Close")
(dom-append (dom-body) _el-p)
(dom-append _el-p _el-p1)
(dom-append _el-p _el-close)
(hs-activate! _el-close)
(dom-dispatch (dom-query-by-id "close") "click" nil)
))
(deftest "hide closes a dialog"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-p (dom-create-element "p")) (_el-close (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-p "Hello")
(dom-set-attr _el-close "id" "close")
(dom-set-attr _el-close "_" "on click hide #d")
(dom-set-inner-html _el-close "Close")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-p)
(dom-append _el-d _el-close)
(hs-activate! _el-close)
(dom-dispatch (dom-query-by-id "close") "click" nil)
(assert (not (dom-has-attr? (dom-query-by-id "d") "open")))
))
(deftest "open on implicit me"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-attr _el-d "_" "on myOpen open")
(dom-set-attr _el-button "_" "on click send myOpen to #d")
(dom-set-inner-html _el-button "Open")
(dom-append (dom-body) _el-d)
(dom-append (dom-body) _el-button)
(hs-activate! _el-d)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert (dom-has-attr? (dom-query-by-id "d") "open"))
))
(deftest "open opens a details element"
(hs-cleanup!)
(let ((_el-d (dom-create-element "details")) (_el-summary (dom-create-element "summary")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-summary "More")
(dom-set-inner-html _el-p "Content")
(dom-set-attr _el-button "_" "on click open #d")
(dom-set-inner-html _el-button "Open")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-summary)
(dom-append _el-d _el-p)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert (dom-has-attr? (dom-query-by-id "d") "open"))
))
(deftest "open opens a dialog"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-p "Hello")
(dom-set-attr _el-button "_" "on click open #d")
(dom-set-inner-html _el-button "Open")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-p)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert (dom-has-attr? (dom-query-by-id "d") "open"))
))
(deftest "open opens a modal dialog (matches :modal)"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-p "Hello")
(dom-set-attr _el-button "_" "on click open #d")
(dom-set-inner-html _el-button "Open")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-p)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
(deftest "open shows a popover"
(hs-cleanup!)
(let ((_el-p (dom-create-element "div")) (_el-p1 (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-p "id" "p")
(dom-set-inner-html _el-p1 "Popover content")
(dom-set-attr _el-button "_" "on click open #p")
(dom-set-inner-html _el-button "Open")
(dom-append (dom-body) _el-p)
(dom-append _el-p _el-p1)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
(deftest "show on already-open dialog is a no-op"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-p "Hello")
(dom-set-attr _el-button "_" "on click show #d")
(dom-set-inner-html _el-button "Show Again")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-p)
(dom-append _el-d _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert (dom-has-attr? (dom-query-by-id "d") "open"))
))
(deftest "show opens a dialog (non-modal)"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-p "Hello")
(dom-set-attr _el-button "_" "on click show #d")
(dom-set-inner-html _el-button "Open")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-p)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert (dom-has-attr? (dom-query-by-id "d") "open"))
))
(deftest "show opens a non-modal dialog (no ::backdrop)"
(hs-cleanup!)
(let ((_el-d (dom-create-element "dialog")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d "id" "d")
(dom-set-inner-html _el-p "Hello")
(dom-set-attr _el-button "_" "on click show #d")
(dom-set-inner-html _el-button "Open")
(dom-append (dom-body) _el-d)
(dom-append _el-d _el-p)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
)
;; ── empty (13 tests) ──
(defsuite "hs-upstream-empty"
(deftest "can empty a checkbox"
(hs-cleanup!)
(let ((_el-cb1 (dom-create-element "input")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-cb1 "id" "cb1")
(dom-set-attr _el-cb1 "type" "checkbox")
(dom-set-attr _el-cb1 "checked" "")
(dom-set-attr _el-button "_" "on click empty #cb1")
(dom-set-inner-html _el-button "Empty")
(dom-append (dom-body) _el-cb1)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert (not (dom-get-prop (dom-query-by-id "cb1") "checked")))
))
(deftest "can empty a form (clears all inputs)"
(hs-cleanup!)
(let ((_el-f1 (dom-create-element "form")) (_el-t2 (dom-create-element "input")) (_el-ta2 (dom-create-element "textarea")) (_el-cb2 (dom-create-element "input")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-f1 "id" "f1")
(dom-set-attr _el-t2 "id" "t2")
(dom-set-attr _el-t2 "type" "text")
(dom-set-attr _el-t2 "value" "val")
(dom-set-attr _el-ta2 "id" "ta2")
(dom-set-inner-html _el-ta2 "text")
(dom-set-attr _el-cb2 "id" "cb2")
(dom-set-attr _el-cb2 "type" "checkbox")
(dom-set-attr _el-cb2 "checked" "")
(dom-set-attr _el-button "_" "on click empty #f1")
(dom-set-inner-html _el-button "Empty")
(dom-append (dom-body) _el-f1)
(dom-append _el-f1 _el-t2)
(dom-append _el-f1 _el-ta2)
(dom-append _el-f1 _el-cb2)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-get-prop (dom-query-by-id "t2") "value") "")
(assert= (dom-get-prop (dom-query-by-id "ta2") "value") "")
(assert (not (dom-get-prop (dom-query-by-id "cb2") "checked")))
))
(deftest "can empty a map"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set :m to {a:1, b:2} as Map then empty :m then put :m.size into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "0")
))
(deftest "can empty a select"
(hs-cleanup!)
(let ((_el-sel1 (dom-create-element "select")) (_el-option (dom-create-element "option")) (_el-option2 (dom-create-element "option")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-sel1 "id" "sel1")
(dom-set-attr _el-option "value" "a")
(dom-set-inner-html _el-option "A")
(dom-set-attr _el-option2 "value" "b")
(dom-set-attr _el-option2 "selected" "")
(dom-set-inner-html _el-option2 "B")
(dom-set-attr _el-button "_" "on click empty #sel1")
(dom-set-inner-html _el-button "Empty")
(dom-append (dom-body) _el-sel1)
(dom-append _el-sel1 _el-option)
(dom-append _el-sel1 _el-option2)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
(deftest "can empty a set"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set :s to [1,2,3] as Set then empty :s then put :s.size into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "0")
))
(deftest "can empty a text input"
(hs-cleanup!)
(let ((_el-t1 (dom-create-element "input")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-t1 "id" "t1")
(dom-set-attr _el-t1 "type" "text")
(dom-set-attr _el-t1 "value" "hello")
(dom-set-attr _el-button "_" "on click empty #t1")
(dom-set-inner-html _el-button "Empty")
(dom-append (dom-body) _el-t1)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-get-prop (dom-query-by-id "t1") "value") "")
))
(deftest "can empty a textarea"
(hs-cleanup!)
(let ((_el-ta1 (dom-create-element "textarea")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-ta1 "id" "ta1")
(dom-set-inner-html _el-ta1 "some text")
(dom-set-attr _el-button "_" "on click empty #ta1")
(dom-set-inner-html _el-button "Empty")
(dom-append (dom-body) _el-ta1)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-get-prop (dom-query-by-id "ta1") "value") "")
))
(deftest "can empty an array"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click set :arr to [1,2,3] then empty :arr then put :arr.length into me")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "0")
))
(deftest "can empty an element"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")) (_el-p (dom-create-element "p")) (_el-p2 (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-inner-html _el-p "hello")
(dom-set-inner-html _el-p2 "world")
(dom-set-attr _el-button "_" "on click empty #d1")
(dom-append (dom-body) _el-d1)
(dom-append _el-d1 _el-p)
(dom-append _el-d1 _el-p2)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "")
))
(deftest "can empty multiple elements"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-p (dom-create-element "p")) (_el-div2 (dom-create-element "div")) (_el-p3 (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-add-class _el-div "clearme")
(dom-set-inner-html _el-p "a")
(dom-add-class _el-div2 "clearme")
(dom-set-inner-html _el-p3 "b")
(dom-set-attr _el-button "_" "on click empty .clearme")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-p)
(dom-append (dom-body) _el-div2)
(dom-append _el-div2 _el-p3)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query ".clearme")) "")
(assert= (dom-text-content (dom-query ".clearme")) "")
))
(deftest "clear is an alias for empty"
(hs-cleanup!)
(let ((_el-t3 (dom-create-element "input")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-t3 "id" "t3")
(dom-set-attr _el-t3 "type" "text")
(dom-set-attr _el-t3 "value" "hello")
(dom-set-attr _el-button "_" "on click clear #t3")
(dom-set-inner-html _el-button "Clear")
(dom-append (dom-body) _el-t3)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-get-prop (dom-query-by-id "t3") "value") "")
))
(deftest "clear works on elements"
(hs-cleanup!)
(let ((_el-d2 (dom-create-element "div")) (_el-p (dom-create-element "p")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-d2 "id" "d2")
(dom-set-inner-html _el-p "content")
(dom-set-attr _el-button "_" "on click clear #d2")
(dom-append (dom-body) _el-d2)
(dom-append _el-d2 _el-p)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "d2")) "")
))
(deftest "empty with no target empties me"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click empty")
(dom-set-inner-html _el-div "content")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
(dom-dispatch _el-div "click" nil)
(assert= (dom-text-content _el-div) "")
))
)
;; ── expressions/arrayIndex (14 tests) ──
(defsuite "hs-upstream-expressions/arrayIndex"
(deftest "can create an array literal"
(assert= (eval-hs "[1, 2, 3]") (list 1 2 3))
)
(deftest "can get the range of first values in an array"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set var to [0,1,2,3,4,5] then put var[..3] as String into #d1")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "0,1,2,3")
))
(deftest "can get the range of last values in an array"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set var to [0,1,2,3,4,5] then put var[3 ..] as String into #d1")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "3,4,5")
))
(deftest "can get the range of last values in an array WITHOUT EXTRA SPACES"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set var to [0,1,2,3,4,5] then put var[3..] as String into #d1")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "3,4,5")
))
(deftest "can get the range of middle values in an array"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set var to [0,1,2,3,4,5] then put var[2 .. 3] as String into #d1")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "2,3")
))
(deftest "can get the range of middle values in an array WITHOUT EXTRA SPACES"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set var to [0,1,2,3,4,5] then put var[2..3] as String into #d1")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "2,3")
))
(deftest "can get the range of middle values in an array using an expression"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set index to 3 then set var to [0,1,2,3,4,5] then put var[(index-1)..(index+1)] as String into #d1")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "2,3,4")
))
(deftest "can index an array value"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set newVar to [10, 20, 30] then put newVar[0] into #d1.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "10")
))
(deftest "can index an array value at the beginning of the array"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set newVar to [10, 20, 30] then put newVar[0] into #d1.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "10")
))
(deftest "can index an array value at the end of the array"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set newVar to [10, 20, 30] then put newVar[2] into #d1.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "30")
))
(deftest "can index an array value in the middle of the array"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set newVar to [10, 20, 30] then put newVar[1] into #d1.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "20")
))
(deftest "can index an array value with an expression"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set newVar to [\"A\", \"B\", \"C\"] then put newVar[1+1] into #d1.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "C")
))
(deftest "errors when index exceeds array length"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set newVar to [10, 20, 30] then put newVar[10] into #d1.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
))
(deftest "errors when indexed value is not an array"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set newVar to \"not-an-array\" then put newVar[0] into #d1.innerHTML")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
))
)
;; ── expressions/arrayLiteral (8 tests) ──
(defsuite "hs-upstream-expressions/arrayLiteral"
(deftest "arrays can contain expressions"
(assert= (eval-hs "[1 + 1, 2 * 3, 10 - 5]") (list 2 6 5))
)
(deftest "arrays containing objects work"
(assert= (eval-hs "[{a: 1}, {b: 2}]") (list "{a: 1}" "{b: 2}"))
)
(deftest "deeply nested array literals work"
(assert= (eval-hs "[[[1]], [[2, 3]]]") (list (list (list 1)) (list (list 2 3))))
)
(deftest "empty array literals work"
(assert= (eval-hs "[]") (list))
)
(deftest "mixed-type array literal works"
(assert= (eval-hs "[1, 'two', true, null]") (list 1 "two" true nil))
)
(deftest "multi element array literal works"
(assert= (eval-hs "[true, false]") (list true false))
)
(deftest "nested array literals work"
(assert= (eval-hs "[[1, 2], [3, 4]]") (list (list 1 2) (list 3 4)))
)
(deftest "one element array literal works"
(assert= (eval-hs "[true]") (list true))
)
)
;; ── expressions/asExpression (42 tests) ──
(defsuite "hs-upstream-expressions/asExpression"
(deftest "can accept custom conversions"
(error "SKIP (untranslated): can accept custom conversions"))
(deftest "can accept custom dynamic conversions"
(error "SKIP (untranslated): can accept custom dynamic conversions"))
(deftest "can use the a modifier if you like"
(error "SKIP (untranslated): can use the a modifier if you like"))
(deftest "can use the an modifier if you'd like"
(assert= (host-get (eval-hs "'{\"foo\":\"bar\"}' as an Object") "foo") "bar")
)
(deftest "collects duplicate text inputs into an array"
(error "SKIP (untranslated): collects duplicate text inputs into an array"))
(deftest "converts a NodeList into HTML"
(error "SKIP (untranslated): converts a NodeList into HTML"))
(deftest "converts a complete form into Values"
(error "SKIP (untranslated): converts a complete form into Values"))
(deftest "converts a form element into Values"
(error "SKIP (untranslated): converts a form element into Values"))
(deftest "converts a form element into Values | FormEncoded"
(error "SKIP (untranslated): converts a form element into Values | FormEncoded"))
(deftest "converts a form element into Values | JSONString"
(error "SKIP (untranslated): converts a form element into Values | JSONString"))
(deftest "converts a query selector into Values"
(hs-cleanup!)
(let ((_el-qsdiv (dom-create-element "div")) (_el-input (dom-create-element "input")) (_el-br (dom-create-element "br")) (_el-input3 (dom-create-element "input")) (_el-br4 (dom-create-element "br")) (_el-input5 (dom-create-element "input")) (_el-input6 (dom-create-element "input")))
(dom-set-attr _el-qsdiv "id" "qsdiv")
(dom-set-attr _el-qsdiv "_" "on click put new
'")
(dom-set-inner-html _el-go "go")
(dom-append (dom-body) _el-target)
(dom-append (dom-body) _el-go)
(hs-activate! _el-go)
(dom-dispatch (dom-query-by-id "go") "click" nil)
(assert= (dom-text-content (dom-query-by-id "target")) "new")
(dom-dispatch (dom-query-by-id "target") "click" nil)
(assert= (dom-text-content (dom-query-by-id "target")) "clicked")
))
(deftest "put into still works as innerHTML"
(hs-cleanup!)
(let ((_el-target (dom-create-element "div")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-target "id" "target")
(dom-set-inner-html _el-target "old")
(dom-set-attr _el-button "_" "on click put \"new\" into #target")
(dom-set-inner-html _el-button "go")
(dom-append (dom-body) _el-target)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "target")) "new")
))
(deftest "set #id replaces element with HTML string"
(hs-cleanup!)
(let ((_el-target (dom-create-element "div")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-target "id" "target")
(dom-set-inner-html _el-target "old")
(dom-set-attr _el-button "_" "on click set #target to \"new \"")
(dom-set-inner-html _el-button "go")
(dom-append (dom-body) _el-target)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "target")) "new")
))
(deftest "set #id replaces element with another element"
(hs-cleanup!)
(let ((_el-target (dom-create-element "div")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-target "id" "target")
(dom-set-inner-html _el-target "old")
(dom-set-attr _el-button "_" "on click make a replaced \"")
(dom-set-inner-html _el-button "go")
(dom-append (dom-body) _el-list)
(dom-append _el-list _el-li)
(dom-append _el-list _el-li2)
(dom-append _el-list _el-li3)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
(deftest "set
in #box to \"done
\"")
(dom-set-inner-html _el-button "go")
(dom-append (dom-body) _el-box)
(dom-append _el-box _el-p)
(dom-append _el-box _el-p2)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
(deftest "set closest replaces ancestor"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")))
(dom-add-class _el-div "wrapper")
(dom-set-attr _el-button "_" "on click set (closest
) to \"replaced
\"")
(dom-set-inner-html _el-button "go")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query ".wrapper")) "replaced")
))
(deftest "swap #a with #b swaps DOM positions"
(hs-cleanup!)
(let ((_el-container (dom-create-element "div")) (_el-a (dom-create-element "div")) (_el-b (dom-create-element "div")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-container "id" "container")
(dom-set-attr _el-a "id" "a")
(dom-set-inner-html _el-a "A")
(dom-set-attr _el-b "id" "b")
(dom-set-inner-html _el-b "B")
(dom-set-attr _el-button "_" "on click swap #a with #b")
(dom-set-inner-html _el-button "go")
(dom-append (dom-body) _el-container)
(dom-append _el-container _el-a)
(dom-append _el-container _el-b)
(dom-append (dom-body) _el-button)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
)
;; ── expressions/attributeRef (22 tests) ──
(defsuite "hs-upstream-expressions/attributeRef"
(deftest "attributeRef can be put as symbol"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click put \"blue\" into [@data-foo]")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can be put as symbol w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click put \"blue\" into @data-foo")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can be put indirectly"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef can be put indirectly w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef can be set as prop"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef can be set as prop w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef can be set as symbol"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click set [@data-foo] to \"blue\"")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can be set as symbol w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click set @data-foo to \"blue\"")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can be set indirectly"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef can be set indirectly w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef can be set through possessive"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click set my [@data-foo] to \"blue\"")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can be set through possessive w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click set my @data-foo to \"blue\"")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can have value in quotes used in add commands"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click add [@data-foo=\"blue\"]")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can have value in quotes used in add commands w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click add @data-foo=\"blue\"")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can have value in quotes with spaces used in add commands"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click add [@data-foo=\"blue green\"]")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can have value in quotes with spaces used in add commands w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click add @data-foo=\"blue green\"")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can have value used in add commands"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click add [@data-foo=blue]")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef can have value used in add commands w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "_" "on click add @data-foo=blue")
(dom-set-attr _el-arDiv "data-foo" "red")
(dom-append (dom-body) _el-arDiv)
(hs-activate! _el-arDiv)
(dom-dispatch (dom-query-by-id "arDiv") "click" nil)
))
(deftest "attributeRef with dashes name works"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "c1")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef with dashes name works w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "data-foo" "c1")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef with no value works"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "foo" "c1")
(dom-append (dom-body) _el-arDiv)
))
(deftest "attributeRef with no value works w/ short syntax"
(hs-cleanup!)
(let ((_el-arDiv (dom-create-element "div")))
(dom-set-attr _el-arDiv "id" "arDiv")
(dom-set-attr _el-arDiv "foo" "c1")
(dom-append (dom-body) _el-arDiv)
))
)
;; ── expressions/beep! (6 tests) ──
(defsuite "hs-upstream-expressions/beep!"
(deftest "beeps a basic value"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click get beep! 10")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "beeps a formatted string value"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click get beep! \"foo\"")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "beeps a null value"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on click get beep! null")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "beeps the result of an ElementCollection"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "foo")
(dom-set-attr _el-div "_" "on click get beep! .foo")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "can be cancelled"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-set-attr _el-div "_" "on hyperscript:beep halt on click get beep! \"foo\"")
(dom-append (dom-body) _el-div)
(hs-activate! _el-div)
))
(deftest "can capture information from event"
(hs-cleanup!)
(let ((_el-beepDiv (dom-create-element "div")))
(dom-set-attr _el-beepDiv "id" "beepDiv")
(dom-set-attr _el-beepDiv "_" "on hyperscript:beep(value) set my @data-value to the value on click get beep! \"foo\"")
(dom-append (dom-body) _el-beepDiv)
(hs-activate! _el-beepDiv)
(dom-dispatch (dom-query-by-id "beepDiv") "click" nil)
))
)
;; ── expressions/blockLiteral (4 tests) ──
(defsuite "hs-upstream-expressions/blockLiteral"
(deftest "basic block literals work"
(error "SKIP (untranslated): basic block literals work"))
(deftest "basic identity works"
(error "SKIP (untranslated): basic identity works"))
(deftest "basic two arg identity works"
(error "SKIP (untranslated): basic two arg identity works"))
(deftest "can map an array"
(error "SKIP (untranslated): can map an array"))
)
;; ── expressions/boolean (2 tests) ──
(defsuite "hs-upstream-expressions/boolean"
(deftest "false boolean literals work"
(assert= (eval-hs "false") false)
)
(deftest "true boolean literals work"
(assert= (eval-hs "true") true)
)
)
;; ── expressions/classRef (9 tests) ──
(defsuite "hs-upstream-expressions/classRef"
(deftest "basic classRef works"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "c1")
(dom-append (dom-body) _el-div)
))
(deftest "basic classRef works w no match"
(error "SKIP (untranslated): basic classRef works w no match"))
(deftest "colon class ref works"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "c1:foo")
(dom-append (dom-body) _el-div)
))
(deftest "dashed class ref works"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "c1-foo")
(dom-append (dom-body) _el-div)
))
(deftest "leading minus class ref works"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "-c1")
(dom-append (dom-body) _el-div)
))
(deftest "multiple colon class ref works"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "c1:foo:bar")
(dom-append (dom-body) _el-div)
))
(deftest "slashes in class references work"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "-c1/22")
(dom-append (dom-body) _el-div)
))
(deftest "tailwind insanity in class references work"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "group-[:nth-of-type(3)_&]:block")
(dom-append (dom-body) _el-div)
))
(deftest "template classRef works"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")))
(dom-add-class _el-div "c1")
(dom-append (dom-body) _el-div)
))
)
;; ── expressions/closest (10 tests) ──
(defsuite "hs-upstream-expressions/closest"
(deftest "attributes can be looked up and referred to in same expression"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-div "foo" "bar")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click put closest @foo into me")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "bar")
))
(deftest "attributes can be set via the closest expression"
(hs-cleanup!)
(let ((_el-outerDiv (dom-create-element "div")) (_el-d1 (dom-create-element "div")))
(dom-set-attr _el-outerDiv "id" "outerDiv")
(dom-set-attr _el-outerDiv "foo" "bar")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click set closest @foo to \"doh\"")
(dom-append (dom-body) _el-outerDiv)
(dom-append _el-outerDiv _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
))
(deftest "attributes can be set via the closest expression 2"
(hs-cleanup!)
(let ((_el-outerDiv2 (dom-create-element "div")) (_el-d1b (dom-create-element "div")))
(dom-set-attr _el-outerDiv2 "id" "outerDiv2")
(dom-set-attr _el-outerDiv2 "foo" "bar")
(dom-set-attr _el-d1b "id" "d1b")
(dom-set-attr _el-d1b "_" "on click set closest @foo to \"doh\"")
(dom-append (dom-body) _el-outerDiv2)
(dom-append _el-outerDiv2 _el-d1b)
(hs-activate! _el-d1b)
(dom-dispatch (dom-query-by-id "d1b") "click" nil)
))
(deftest "attributes resolve as attributes"
(hs-cleanup!)
(let ((_el-d3 (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
(dom-set-attr _el-d3 "id" "d3")
(dom-set-attr _el-d3 "foo" "bar")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d2 "id" "d2")
(dom-append (dom-body) _el-d3)
(dom-append _el-d3 _el-d1)
(dom-append _el-d3 _el-d2)
))
(deftest "basic query return values"
(hs-cleanup!)
(let ((_el-d3 (dom-create-element "div")) (_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
(dom-set-attr _el-d3 "id" "d3")
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d2 "id" "d2")
(dom-append (dom-body) _el-d3)
(dom-append _el-d3 _el-d1)
(dom-append _el-d3 _el-d2)
))
(deftest "closest does not consume a following where clause"
(hs-cleanup!)
(let ((_el-table (dom-create-element "table")) (_el-tr (dom-create-element "tr")) (_el-td (dom-create-element "td")) (_el-input (dom-create-element "input")) (_el-input4 (dom-create-element "input")) (_el-master (dom-create-element "input")) (_el-out (dom-create-element "div")))
(dom-add-class _el-input "cb")
(dom-set-attr _el-input "type" "checkbox")
(dom-add-class _el-input4 "cb")
(dom-set-attr _el-input4 "type" "checkbox")
(dom-set-attr _el-master "id" "master")
(dom-set-attr _el-master "_" "set :others to does not exist") false)
)
(deftest "does not follow works"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-b (dom-create-element "div")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-b "id" "b")
(dom-append (dom-body) _el-a)
(dom-append (dom-body) _el-b)
))
(deftest "does not match works"
(hs-cleanup!)
(let ((_el-mDiv (dom-create-element "div")))
(dom-set-attr _el-mDiv "id" "mDiv")
(dom-add-class _el-mDiv "foo")
(dom-append (dom-body) _el-mDiv)
))
(deftest "does not match works w/ strings"
(assert= (eval-hs "'a' does not match '.*'") false)
(assert= (eval-hs "'a' does not match 'b'") true)
)
(deftest "does not precede works"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-b (dom-create-element "div")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-b "id" "b")
(dom-append (dom-body) _el-a)
(dom-append (dom-body) _el-b)
))
(deftest "does not start with works"
(assert= (eval-hs "'hello world' does not start with 'hello'") false)
(assert= (eval-hs "'hello world' does not start with 'world'") true)
)
(deftest "ends with coerces to string"
(assert= (eval-hs "123 ends with '23'") true)
(assert= (eval-hs "123 ends with '12'") false)
)
(deftest "ends with ignoring case works"
(assert= (eval-hs "'Hello World' ends with 'world' ignoring case") true)
(assert= (eval-hs "'Hello World' ends with 'WORLD' ignoring case") true)
(assert= (eval-hs "'Hello World' ends with 'hello' ignoring case") false)
)
(deftest "ends with null is false"
(assert= (eval-hs "null ends with 'x'") false)
(assert= (eval-hs "null does not end with 'x'") true)
)
(deftest "ends with works"
(assert= (eval-hs "'hello world' ends with 'world'") true)
(assert= (eval-hs "'hello world' ends with 'hello'") false)
(assert= (eval-hs "'hello' ends with 'hello'") true)
(assert= (eval-hs "'' ends with 'x'") false)
)
(deftest "english greater than or equal works"
(assert= (eval-hs "1 is greater than or equal to 2") false)
(assert= (eval-hs "2 is greater than or equal to 1") true)
(assert= (eval-hs "2 is greater than or equal to 2") true)
)
(deftest "english greater than works"
(assert= (eval-hs "1 is greater than 2") false)
(assert= (eval-hs "2 is greater than 1") true)
(assert= (eval-hs "2 is greater than 2") false)
)
(deftest "english less than or equal works"
(assert= (eval-hs "1 is less than or equal to 2") true)
(assert= (eval-hs "2 is less than or equal to 1") false)
(assert= (eval-hs "2 is less than or equal to 2") true)
)
(deftest "english less than works"
(assert= (eval-hs "1 is less than 2") true)
(assert= (eval-hs "2 is less than 1") false)
(assert= (eval-hs "2 is less than 2") false)
)
(deftest "equal works"
(assert= (eval-hs "1 == 2") false)
(assert= (eval-hs "2 == 1") false)
(assert= (eval-hs "2 == 2") true)
)
(deftest "equals works"
(assert= (eval-hs "1 equals 2") false)
(assert= (eval-hs "2 equals 1") false)
(assert= (eval-hs "2 equals 2") true)
)
(deftest "exists works"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")) (_el-d3 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-add-class _el-d1 "c1")
(dom-set-attr _el-d2 "id" "d2")
(dom-add-class _el-d2 "c1")
(dom-set-attr _el-d3 "id" "d3")
(dom-add-class _el-d3 "c1")
(dom-append (dom-body) _el-d1)
(dom-append (dom-body) _el-d2)
(dom-append (dom-body) _el-d3)
))
(deftest "follows works"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-b (dom-create-element "div")) (_el-c (dom-create-element "div")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-b "id" "b")
(dom-set-attr _el-c "id" "c")
(dom-append (dom-body) _el-a)
(dom-append (dom-body) _el-b)
(dom-append (dom-body) _el-c)
))
(deftest "greater than or equal works"
(assert= (eval-hs "1 >= 2") false)
(assert= (eval-hs "2 >= 1") true)
(assert= (eval-hs "2 >= 2") true)
)
(deftest "greater than works"
(assert= (eval-hs "1 > 2") false)
(assert= (eval-hs "2 > 1") true)
(assert= (eval-hs "2 > 2") false)
)
(deftest "include works"
(let ((foo "foo") (foobar "foobar")) (assert= (eval-hs "foo includes foobar") false))
(let ((foo "foo") (foobar "foobar")) (assert= (eval-hs "foobar includes foo") true))
(let ((foo "foo") (foobar "foobar")) (assert= (eval-hs "foo does not include foobar") true))
(let ((foo "foo") (foobar "foobar")) (assert= (eval-hs "foobar does not include foo") false))
)
(deftest "includes works with arrays"
(let ((that 1)) (assert= (eval-hs "I include that") true))
(let ((that "[1")) (assert= (eval-hs "that includes me") true))
)
(deftest "includes works with css literals"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")) (_el-d2 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-add-class _el-d1 "outer")
(dom-set-attr _el-d2 "id" "d2")
(dom-append (dom-body) _el-d1)
(dom-append _el-d1 _el-d2)
))
(deftest "is a Node works via instanceof"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click if I am a Node put \"yes\" into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "yes")
))
(deftest "is a works"
(assert= (eval-hs "null is a String") true)
(assert= (eval-hs "null is a String!") false)
(assert= (eval-hs "'' is a String!") true)
)
(deftest "is a works with instanceof fallback"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click if I am a Element put \"yes\" into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "yes")
))
(deftest "is an works"
(assert= (eval-hs "null is an String") true)
(assert= (eval-hs "null is an String!") false)
(assert= (eval-hs "'' is an String!") true)
)
(deftest "is between works"
(assert= (eval-hs "5 is between 1 and 10") true)
(assert= (eval-hs "1 is between 1 and 10") true)
(assert= (eval-hs "10 is between 1 and 10") true)
(assert= (eval-hs "0 is between 1 and 10") false)
(assert= (eval-hs "11 is between 1 and 10") false)
)
(deftest "is boolean property works in where clause"
(hs-cleanup!)
(let ((_el-input (dom-create-element "input")) (_el-input1 (dom-create-element "input")) (_el-input2 (dom-create-element "input")))
(dom-add-class _el-input "cb")
(dom-set-attr _el-input "type" "checkbox")
(dom-set-attr _el-input "checked" "checked")
(dom-add-class _el-input1 "cb")
(dom-set-attr _el-input1 "type" "checkbox")
(dom-add-class _el-input2 "cb")
(dom-set-attr _el-input2 "type" "checkbox")
(dom-set-attr _el-input2 "checked" "checked")
(dom-append (dom-body) _el-input)
(dom-append (dom-body) _el-input1)
(dom-append (dom-body) _el-input2)
))
(deftest "is boolean property works with disabled"
(hs-cleanup!)
(let ((_el-b1 (dom-create-element "button")) (_el-b2 (dom-create-element "button")))
(dom-set-attr _el-b1 "id" "b1")
(dom-set-attr _el-b1 "disabled" "")
(dom-set-inner-html _el-b1 "Disabled")
(dom-set-attr _el-b2 "id" "b2")
(dom-set-inner-html _el-b2 "Enabled")
(dom-append (dom-body) _el-b1)
(dom-append (dom-body) _el-b2)
))
(deftest "is empty works"
(assert= (eval-hs "undefined is empty") true)
(assert= (eval-hs "'' is empty") true)
(assert= (eval-hs "[] is empty") true)
(assert= (eval-hs "'not empty' is empty") false)
(assert= (eval-hs "1000 is empty") false)
(assert= (eval-hs "[1,2,3] is empty") false)
(assert= (eval-hs ".aClassThatDoesNotExist is empty") true)
)
(deftest "is equal to works"
(assert= (eval-hs "1 is equal to 2") false)
(assert= (eval-hs "2 is equal to 1") false)
(assert= (eval-hs "2 is equal to 2") true)
)
(deftest "is equal works without to"
(assert= (eval-hs "2 is equal 2") true)
(assert= (eval-hs "2 is equal 1") false)
)
(deftest "is falls back to boolean property when rhs is undefined"
(hs-cleanup!)
(let ((_el-c1 (dom-create-element "input")) (_el-c2 (dom-create-element "input")))
(dom-set-attr _el-c1 "id" "c1")
(dom-set-attr _el-c1 "type" "checkbox")
(dom-set-attr _el-c1 "checked" "checked")
(dom-set-attr _el-c2 "id" "c2")
(dom-set-attr _el-c2 "type" "checkbox")
(dom-append (dom-body) _el-c1)
(dom-append (dom-body) _el-c2)
))
(deftest "is ignoring case works"
(assert= (eval-hs "'Hello' is 'hello' ignoring case") true)
(assert= (eval-hs "'Hello' is 'HELLO' ignoring case") true)
(assert= (eval-hs "'Hello' is 'world' ignoring case") false)
)
(deftest "is in works"
(assert= (eval-hs "1 is in [1, 2]") true)
(assert= (eval-hs "2 is in [1, 2]") true)
(assert= (eval-hs "3 is in [1, 2]") false)
(assert= (eval-hs "3 is in null") false)
)
(deftest "is not a works"
(assert= (eval-hs "null is not a String") false)
(assert= (eval-hs "null is not a String!") true)
(assert= (eval-hs "'' is not a String!") false)
)
(deftest "is not a works with instanceof fallback"
(hs-cleanup!)
(let ((_el-d1 (dom-create-element "div")))
(dom-set-attr _el-d1 "id" "d1")
(dom-set-attr _el-d1 "_" "on click if \"hello\" is not a Element put \"yes\" into me")
(dom-append (dom-body) _el-d1)
(hs-activate! _el-d1)
(dom-dispatch (dom-query-by-id "d1") "click" nil)
(assert= (dom-text-content (dom-query-by-id "d1")) "yes")
))
(deftest "is not an works"
(assert= (eval-hs "null is not an String") false)
(assert= (eval-hs "null is not an String!") true)
(assert= (eval-hs "'' is not an String!") false)
)
(deftest "is not between works"
(assert= (eval-hs "5 is not between 1 and 10") false)
(assert= (eval-hs "0 is not between 1 and 10") true)
(assert= (eval-hs "11 is not between 1 and 10") true)
(assert= (eval-hs "1 is not between 1 and 10") false)
(assert= (eval-hs "10 is not between 1 and 10") false)
)
(deftest "is not empty works"
(assert= (eval-hs "undefined is not empty") false)
(assert= (eval-hs "'' is not empty") false)
(assert= (eval-hs "[] is not empty") false)
(assert= (eval-hs "'not empty' is not empty") true)
(assert= (eval-hs "1000 is not empty") true)
(assert= (eval-hs "[1,2,3] is not empty") true)
)
(deftest "is not equal to works"
(assert= (eval-hs "1 is not equal to 2") true)
(assert= (eval-hs "2 is not equal to 1") true)
(assert= (eval-hs "2 is not equal to 2") false)
)
(deftest "is not equal works without to"
(assert= (eval-hs "2 is not equal 2") false)
(assert= (eval-hs "2 is not equal 1") true)
)
(deftest "is not falls back to boolean property when rhs is undefined"
(hs-cleanup!)
(let ((_el-c1 (dom-create-element "input")) (_el-c2 (dom-create-element "input")))
(dom-set-attr _el-c1 "id" "c1")
(dom-set-attr _el-c1 "type" "checkbox")
(dom-set-attr _el-c1 "checked" "checked")
(dom-set-attr _el-c2 "id" "c2")
(dom-set-attr _el-c2 "type" "checkbox")
(dom-append (dom-body) _el-c1)
(dom-append (dom-body) _el-c2)
))
(deftest "is not ignoring case works"
(assert= (eval-hs "'Hello' is not 'world' ignoring case") true)
(assert= (eval-hs "'Hello' is not 'hello' ignoring case") false)
)
(deftest "is not in works"
(assert= (eval-hs "1 is not in [1, 2]") false)
(assert= (eval-hs "2 is not in [1, 2]") false)
(assert= (eval-hs "3 is not in [1, 2]") true)
(assert= (eval-hs "3 is not in null") true)
)
(deftest "is not null still works as equality"
(assert= (eval-hs "5 is not null") true)
(assert= (eval-hs "null is not null") false)
)
(deftest "is not really equal to works"
(assert= (eval-hs "1 is not really equal to 2") true)
(assert= (eval-hs "2 is not really equal to 1") true)
(assert= (eval-hs "2 is not really equal to '2'") true)
(assert= (eval-hs "2 is not really equal to 2") false)
)
(deftest "is not really works without equal to"
(assert= (eval-hs "2 is not really '2'") true)
(assert= (eval-hs "2 is not really 2") false)
)
(deftest "is not undefined still works as equality"
(assert= (eval-hs "5 is not undefined") true)
(assert= (eval-hs "null is not undefined") false)
)
(deftest "is not works"
(assert= (eval-hs "1 is not 2") true)
(assert= (eval-hs "2 is not 1") true)
(assert= (eval-hs "2 is not 2") false)
)
(deftest "is really equal to works"
(assert= (eval-hs "1 is really equal to 2") false)
(assert= (eval-hs "2 is really equal to 1") false)
(assert= (eval-hs "2 is really equal to '2'") false)
(assert= (eval-hs "2 is really equal to 2") true)
)
(deftest "is really works without equal to"
(assert= (eval-hs "2 is really 2") true)
(assert= (eval-hs "2 is really '2'") false)
)
(deftest "is still does equality when rhs variable exists"
(let ((x 5) (y 5)) (assert= (eval-hs "x is y") true))
(let ((x 5) (y 6)) (assert= (eval-hs "x is y") false))
)
(deftest "is works"
(assert= (eval-hs "1 is 2") false)
(assert= (eval-hs "2 is 1") false)
(assert= (eval-hs "2 is 2") true)
)
(deftest "less than or equal works"
(assert= (eval-hs "1 <= 2") true)
(assert= (eval-hs "2 <= 1") false)
(assert= (eval-hs "2 <= 2") true)
)
(deftest "less than works"
(assert= (eval-hs "1 < 2") true)
(assert= (eval-hs "2 < 1") false)
(assert= (eval-hs "2 < 2") false)
)
(deftest "match works"
(hs-cleanup!)
(let ((_el-mDiv (dom-create-element "div")))
(dom-set-attr _el-mDiv "id" "mDiv")
(dom-add-class _el-mDiv "foo")
(dom-append (dom-body) _el-mDiv)
))
(deftest "match works w/ strings"
(assert= (eval-hs "'a' matches '.*'") true)
(assert= (eval-hs "'a' matches 'b'") false)
)
(deftest "matches ignoring case works"
(assert= (eval-hs "'Hello' matches 'hello' ignoring case") true)
(assert= (eval-hs "'Hello' matches 'HELLO' ignoring case") true)
)
(deftest "not equal works"
(assert= (eval-hs "1 != 2") true)
(assert= (eval-hs "2 != 1") true)
(assert= (eval-hs "2 != 2") false)
)
(deftest "precedes with null is false"
(assert= (eval-hs "null precedes null") false)
(assert= (eval-hs "null does not precede null") true)
)
(deftest "precedes works"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-b (dom-create-element "div")) (_el-c (dom-create-element "div")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-b "id" "b")
(dom-set-attr _el-c "id" "c")
(dom-append (dom-body) _el-a)
(dom-append (dom-body) _el-b)
(dom-append (dom-body) _el-c)
))
(deftest "really equals works"
(assert= (eval-hs "1 really equals 2") false)
(assert= (eval-hs "2 really equals 1") false)
(assert= (eval-hs "2 really equals 2") true)
)
(deftest "starts with coerces to string"
(assert= (eval-hs "123 starts with '12'") true)
(assert= (eval-hs "123 starts with '23'") false)
)
(deftest "starts with ignoring case works"
(assert= (eval-hs "'Hello World' starts with 'hello' ignoring case") true)
(assert= (eval-hs "'Hello World' starts with 'HELLO' ignoring case") true)
(assert= (eval-hs "'Hello World' starts with 'world' ignoring case") false)
)
(deftest "starts with null is false"
(assert= (eval-hs "null starts with 'x'") false)
(assert= (eval-hs "null does not start with 'x'") true)
)
(deftest "starts with works"
(assert= (eval-hs "'hello world' starts with 'hello'") true)
(assert= (eval-hs "'hello world' starts with 'world'") false)
(assert= (eval-hs "'hello' starts with 'hello'") true)
(assert= (eval-hs "'' starts with 'x'") false)
)
(deftest "triple equal works"
(assert= (eval-hs "1 === 2") false)
(assert= (eval-hs "2 === 1") false)
(assert= (eval-hs "2 === 2") true)
)
(deftest "triple not equal works"
(assert= (eval-hs "1 !== 2") true)
(assert= (eval-hs "2 !== 1") true)
(assert= (eval-hs "2 !== 2") false)
)
)
;; ── expressions/cookies (5 tests) ──
(defsuite "hs-upstream-expressions/cookies"
(deftest "basic clear cookie values work"
(error "SKIP (untranslated): basic clear cookie values work"))
(deftest "basic set cookie values work"
(error "SKIP (untranslated): basic set cookie values work"))
(deftest "iterate cookies values work"
(error "SKIP (untranslated): iterate cookies values work"))
(deftest "length is 0 when no cookies are set"
(error "SKIP (untranslated): length is 0 when no cookies are set"))
(deftest "update cookie values work"
(error "SKIP (untranslated): update cookie values work"))
)
;; ── expressions/dom-scope (20 tests) ──
(defsuite "hs-upstream-expressions/dom-scope"
(deftest "always reacts to ^var changes"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-output (dom-create-element "output")))
(dom-set-attr _el-div "_" "init set ^name to 'alice'")
(dom-set-attr _el-button "_" "on click set ^name to 'bob'")
(dom-set-inner-html _el-button "rename")
(dom-set-attr _el-output "_" "live put 'Hello ' + ^name into me")
(dom-set-inner-html _el-output "loading")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(dom-append _el-div _el-output)
(hs-activate! _el-div)
(hs-activate! _el-button)
(hs-activate! _el-output)
(dom-dispatch _el-button "click" nil)
))
(deftest "bind works with ^var"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-input (dom-create-element "input")) (_el-output (dom-create-element "output")))
(dom-set-attr _el-div "_" "init set ^search to ''")
(dom-set-attr _el-input "_" "bind ^search and my value")
(dom-set-attr _el-input "type" "text")
(dom-set-attr _el-output "_" "when ^search changes put it into me")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-input)
(dom-append _el-div _el-output)
(hs-activate! _el-div)
(hs-activate! _el-input)
(hs-activate! _el-output)
(dom-set-prop _el-input "value" "hello")
(dom-dispatch _el-input "input" nil)
))
(deftest "child reads ^var set by parent"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set ^count to 42")
(dom-set-attr _el-span "_" "on click put ^count into me")
(dom-set-inner-html _el-span "0")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-span)
(hs-activate! _el-div)
(hs-activate! _el-span)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "42")
))
(deftest "child write updates the ancestor, not a local copy"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set ^shared to 0")
(dom-set-attr _el-button "_" "on click set ^shared to 10")
(dom-set-inner-html _el-button "set")
(dom-set-attr _el-span "_" "on click put ^shared into me")
(dom-set-inner-html _el-span "0")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(dom-append _el-div _el-span)
(hs-activate! _el-div)
(hs-activate! _el-button)
(hs-activate! _el-span)
(dom-dispatch _el-button "click" nil)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "10")
))
(deftest "child writes ^var and parent sees it"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set ^count to 0")
(dom-set-attr _el-button "_" "on click set ^count to 99")
(dom-set-inner-html _el-button "set")
(dom-set-attr _el-span "_" "on click put ^count into me")
(dom-set-inner-html _el-span "0")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(dom-append _el-div _el-span)
(hs-activate! _el-div)
(hs-activate! _el-button)
(hs-activate! _el-span)
(dom-dispatch _el-button "click" nil)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "99")
))
(deftest "closest ancestor wins (shadowing)"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-div1 (dom-create-element "div")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set ^color to 'red'")
(dom-set-attr _el-div1 "_" "init set ^color to 'blue'")
(dom-set-attr _el-span "_" "on click put ^color into me")
(dom-set-inner-html _el-span "empty")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-div1)
(dom-append _el-div1 _el-span)
(hs-activate! _el-div)
(hs-activate! _el-div1)
(hs-activate! _el-span)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "blue")
))
(deftest "dedup prevents re-fire on same ^var value"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-output (dom-create-element "output")) (_el-button (dom-create-element "button")) (_el-diff (dom-create-element "button")))
(dom-set-attr _el-div "_" "init set ^val to 'same'")
(dom-set-attr _el-output "_" "when ^val changes increment :runs then put :runs into me")
(dom-set-attr _el-button "_" "on click set ^val to 'same'")
(dom-set-inner-html _el-button "same")
(dom-set-attr _el-diff "id" "diff")
(dom-set-attr _el-diff "_" "on click set ^val to 'different'")
(dom-set-inner-html _el-diff "diff")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-output)
(dom-append _el-div _el-button)
(dom-append _el-div _el-diff)
(hs-activate! _el-div)
(hs-activate! _el-output)
(hs-activate! _el-button)
(hs-activate! _el-diff)
(dom-dispatch (dom-query "button:text("same")") "click" nil)
(assert= (dom-text-content _el-output) "1")
(dom-dispatch (dom-query-by-id "diff") "click" nil)
(assert= (dom-text-content _el-output) "2")
))
(deftest "deeply nested child reads ^var from grandparent"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-div1 (dom-create-element "div")) (_el-div2 (dom-create-element "div")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set ^name to 'alice'")
(dom-set-attr _el-span "_" "on click put ^name into me")
(dom-set-inner-html _el-span "empty")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-div1)
(dom-append _el-div1 _el-div2)
(dom-append _el-div2 _el-span)
(hs-activate! _el-div)
(hs-activate! _el-span)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "alice")
))
(deftest "derived ^var chains reactively"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-span (dom-create-element "span")) (_el-span2 (dom-create-element "span")) (_el-output (dom-create-element "output")) (_el-price-btn (dom-create-element "button")) (_el-qty-btn (dom-create-element "button")))
(dom-set-attr _el-div "_" "init set ^price to 10 then set ^qty to 2 then set ^total to 20")
(dom-set-attr _el-span "_" "when ^price changes set ^total to (^price * ^qty)")
(dom-set-attr _el-span2 "_" "when ^qty changes set ^total to (^price * ^qty)")
(dom-set-attr _el-output "_" "when ^total changes put it into me")
(dom-set-attr _el-price-btn "id" "price-btn")
(dom-set-attr _el-price-btn "_" "on click set ^price to 25")
(dom-set-inner-html _el-price-btn "set price")
(dom-set-attr _el-qty-btn "id" "qty-btn")
(dom-set-attr _el-qty-btn "_" "on click set ^qty to 5")
(dom-set-inner-html _el-qty-btn "set qty")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-span)
(dom-append _el-div _el-span2)
(dom-append _el-div _el-output)
(dom-append _el-div _el-price-btn)
(dom-append _el-div _el-qty-btn)
(hs-activate! _el-div)
(hs-activate! _el-span)
(hs-activate! _el-span2)
(hs-activate! _el-output)
(hs-activate! _el-price-btn)
(hs-activate! _el-qty-btn)
(dom-dispatch (dom-query-by-id "price-btn") "click" nil)
(dom-dispatch (dom-query-by-id "qty-btn") "click" nil)
))
(deftest "dom keyword works as scope modifier"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set dom count to 42")
(dom-set-attr _el-span "_" "on click put dom count into me")
(dom-set-inner-html _el-span "0")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-span)
(hs-activate! _el-div)
(hs-activate! _el-span)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "42")
))
(deftest "effect stops when element is removed"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-output (dom-create-element "output")) (_el-button (dom-create-element "button")))
(dom-set-attr _el-div "_" "init set ^msg to 'hello'")
(dom-set-attr _el-output "_" "when ^msg changes put it into me")
(dom-set-attr _el-button "_" "on click set ^msg to 'updated'")
(dom-set-inner-html _el-button "update")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-output)
(dom-append _el-div _el-button)
(hs-activate! _el-div)
(hs-activate! _el-output)
(hs-activate! _el-button)
(dom-dispatch _el-button "click" nil)
))
(deftest "increment works on inherited var"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set ^count to 0")
(dom-set-attr _el-button "_" "on click increment ^count")
(dom-set-inner-html _el-button "+1")
(dom-set-attr _el-span "_" "on click put ^count into me")
(dom-set-inner-html _el-span "0")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(dom-append _el-div _el-span)
(hs-activate! _el-div)
(hs-activate! _el-button)
(hs-activate! _el-span)
(dom-dispatch _el-button "click" nil)
(dom-dispatch _el-button "click" nil)
(dom-dispatch _el-button "click" nil)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "3")
))
(deftest "multiple children react to same ^var"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-a (dom-create-element "span")) (_el-b (dom-create-element "span")))
(dom-set-attr _el-div "_" "init set ^color to 'red'")
(dom-set-attr _el-button "_" "on click set ^color to 'blue'")
(dom-set-inner-html _el-button "change")
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-a "_" "when ^color changes put it into me")
(dom-set-attr _el-b "id" "b")
(dom-set-attr _el-b "_" "when ^color changes put it into me")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(dom-append _el-div _el-a)
(dom-append _el-div _el-b)
(hs-activate! _el-div)
(hs-activate! _el-button)
(hs-activate! _el-a)
(hs-activate! _el-b)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content (dom-query-by-id "a")) "blue")
(assert= (dom-text-content (dom-query-by-id "b")) "blue")
))
(deftest "on clause targets a specific ancestor"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-div1 (dom-create-element "div")) (_el-span (dom-create-element "span")))
(dom-add-class _el-div "outer")
(dom-set-attr _el-div "_" "init set ^outerVal to 'outer'")
(dom-add-class _el-div1 "inner")
(dom-set-attr _el-div1 "_" "init set ^innerVal to 'inner'")
(dom-set-attr _el-span "_" "on click put ^outerVal on closest .outer into me")
(dom-set-inner-html _el-span "read")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-div1)
(dom-append _el-div1 _el-span)
(hs-activate! _el-div)
(hs-activate! _el-div1)
(hs-activate! _el-span)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "outer")
))
(deftest "on clause with id reference"
(hs-cleanup!)
(let ((_el-state-holder (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-state-holder "id" "state-holder")
(dom-set-attr _el-button "_" "on click set ^count on #state-holder to 99")
(dom-set-inner-html _el-button "set")
(dom-set-attr _el-span "_" "on click put ^count on #state-holder into me")
(dom-set-inner-html _el-span "read")
(dom-append (dom-body) _el-state-holder)
(dom-append (dom-body) _el-button)
(dom-append (dom-body) _el-span)
(hs-activate! _el-button)
(hs-activate! _el-span)
(dom-dispatch _el-button "click" nil)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "99")
))
(deftest "set ^var on explicit element"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-span (dom-create-element "span")))
(dom-add-class _el-div "store")
(dom-set-attr _el-button "_" "on click set ^data on closest .store to 'hello'")
(dom-set-inner-html _el-button "set")
(dom-set-attr _el-span "_" "on click put ^data on closest .store into me")
(dom-set-inner-html _el-span "read")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(dom-append _el-div _el-span)
(hs-activate! _el-button)
(hs-activate! _el-span)
(dom-dispatch _el-button "click" nil)
(dom-dispatch _el-span "click" nil)
(assert= (dom-text-content _el-span) "hello")
))
(deftest "sibling subtrees have independent ^vars"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-span (dom-create-element "span")) (_el-b (dom-create-element "div")) (_el-span3 (dom-create-element "span")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-a "_" "init set ^val to 'A'")
(dom-set-attr _el-span "_" "on click put ^val into me")
(dom-set-inner-html _el-span "empty")
(dom-set-attr _el-b "id" "b")
(dom-set-attr _el-b "_" "init set ^val to 'B'")
(dom-set-attr _el-span3 "_" "on click put ^val into me")
(dom-set-inner-html _el-span3 "empty")
(dom-append (dom-body) _el-a)
(dom-append _el-a _el-span)
(dom-append (dom-body) _el-b)
(dom-append _el-b _el-span3)
(hs-activate! _el-a)
(hs-activate! _el-span)
(hs-activate! _el-b)
(hs-activate! _el-span3)
(dom-dispatch (dom-query "#a span") "click" nil)
(assert= (dom-text-content (dom-query "#a span")) "A")
(dom-dispatch (dom-query "#b span") "click" nil)
(assert= (dom-text-content (dom-query "#b span")) "B")
))
(deftest "sibling subtrees react independently with ^var"
(hs-cleanup!)
(let ((_el-a (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-output (dom-create-element "output")) (_el-b (dom-create-element "div")) (_el-button4 (dom-create-element "button")) (_el-output5 (dom-create-element "output")))
(dom-set-attr _el-a "id" "a")
(dom-set-attr _el-a "_" "init set ^val to 0")
(dom-set-attr _el-button "_" "on click increment ^val")
(dom-set-inner-html _el-button "+1")
(dom-set-attr _el-output "_" "when ^val changes put it into me")
(dom-set-inner-html _el-output "0")
(dom-set-attr _el-b "id" "b")
(dom-set-attr _el-b "_" "init set ^val to 0")
(dom-set-attr _el-button4 "_" "on click increment ^val")
(dom-set-inner-html _el-button4 "+1")
(dom-set-attr _el-output5 "_" "when ^val changes put it into me")
(dom-set-inner-html _el-output5 "0")
(dom-append (dom-body) _el-a)
(dom-append _el-a _el-button)
(dom-append _el-a _el-output)
(dom-append (dom-body) _el-b)
(dom-append _el-b _el-button4)
(dom-append _el-b _el-output5)
(hs-activate! _el-a)
(hs-activate! _el-button)
(hs-activate! _el-output)
(hs-activate! _el-b)
(hs-activate! _el-button4)
(hs-activate! _el-output5)
(dom-dispatch (dom-query "#a button") "click" nil)
(dom-dispatch (dom-query "#a button") "click" nil)
(assert= (dom-text-content (dom-query "#a output")) "2")
(assert= (dom-text-content (dom-query "#b output")) "0")
(dom-dispatch (dom-query "#b button") "click" nil)
(assert= (dom-text-content (dom-query "#b output")) "1")
(assert= (dom-text-content (dom-query "#a output")) "2")
))
(deftest "when reacts to ^var changes"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-output (dom-create-element "output")))
(dom-set-attr _el-div "_" "init set ^count to 0")
(dom-set-attr _el-button "_" "on click increment ^count")
(dom-set-inner-html _el-button "+1")
(dom-set-attr _el-output "_" "when ^count changes put it into me")
(dom-set-inner-html _el-output "0")
(dom-append (dom-body) _el-div)
(dom-append _el-div _el-button)
(dom-append _el-div _el-output)
(hs-activate! _el-div)
(hs-activate! _el-button)
(hs-activate! _el-output)
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content _el-output) "1")
(dom-dispatch _el-button "click" nil)
(assert= (dom-text-content _el-output) "2")
))
(deftest "write to ^var not found anywhere creates on current element"
(hs-cleanup!)
(let ((_el-div (dom-create-element "div")) (_el-button (dom-create-element "button")) (_el-span (dom-create-element "span")))
(dom-set-attr _el-button "_" "on click set ^newvar to 'created' then put ^newvar into next