Parser `parse-toggle-cmd`: after the leading class ref, collect any
additional class refs and treat `toggle .foo .bar` as `toggle-between`
(pair-only). Recognise a `until EVENT [from SOURCE]` modifier and emit
a new `toggle-class-until` AST node. Compiler handles the new node by
emitting `(begin (hs-toggle-class! tgt cls) (hs-wait-for src ev)
(hs-toggle-class! tgt cls))` which uses the existing event-waiter
machinery to flip the class back when the specified event fires.
Remaining toggle test (`can toggle for a fixed amount of time`)
depends on the mock's sync io-sleep resuming immediately — the click
handler toggles on/off synchronously, so the pre-timeout assertion
can never see the `.foo` class present. Needs an async scheduler in
the mock to handle.
Suite hs-upstream-toggle: 22/25 → 24/25. Smoke 0-195: 162/195
unchanged.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
{0: 41, 1: 42} was raising 'dict-set!: dict key val' because the parser
kept numeric keys as numbers in the entry dict, but SX dicts require string
keys. Now we str-coerce number-type tokens during jp-parse-object-entry.
Unblocks a huge chunk of test262 array-like-receiver tests that build
{length: N, 0: v, 1: v, ...} literals.
3 new tests, 453/455 total.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Two fixes in `tests/hs-run-filtered.js`: (a) `mt` (matches-selector)
now splits comma-separated selector lists and matches if any clause
matches, so `qsa("#d1, #d2")` returns both elements. (b) `host-get` on
an `El` for `innerText` returns `textContent` (DOM-level alias) so
`when its innerText contains "foo"` predicates can see the mock's
stored text.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Adds js-invoke-function-method dispatched from js-invoke-method when the
receiver is a JS function (lambda/function/component/callable-dict) and the
method name is one of call/apply/bind/toString/name/length.
call and apply bind this around a single call; bind returns a closure with
prepended args. toString returns the native-code placeholder.
6 unit tests, 450/452 total (Array.prototype.push.call with arrayLike still
fails — tracked as the 455x 'Not callable array-like' scoreboard item which
needs array methods to treat dict-with-length as a list).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Three parts: (a) `runtime.sx` hs-hide-one!/hs-show-one! consult a new
`_hs-hide-strategies` dict (and `_hs-default-hide-strategy` override)
before falling through to the built-in display/opacity/etc. cases. The
strategy fn is called directly with (op, el, arg). New setters
`hs-set-hide-strategies!` and `hs-set-default-hide-strategy!`. (b)
`generate-sx-tests.py` `_hs_config_setup_ops` recognises
`_hyperscript.config.defaultHideShowStrategy = "X"`, `delete …default…`,
and `hideShowStrategies = { NAME: function (op, el, arg) { if …
classList.add/remove } }` with brace-matched function body extraction.
(c) Pre-setup emitter handles `__hs_config__` pseudo-name by emitting
the SX expression as-is (not a window.X = Y assignment).
Suite hs-upstream-hide: 12/16 → 15/16. Remaining test
(`hide element then show element retains original display`) needs
`on click 1 hide` / `on click 2 show` count-filtered events — separate
feature. Smoke 0-195: 162/195 unchanged.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Rework test262-runner.py to support --workers N parallel shards, each running
a long-lived sx_server session. Replace thread-per-readline with a select-based
raw-fd line buffer.
On 2-core machines, 1 worker still beats 2 (OCaml eval is CPU-bound and starves
when shared). Auto-defaults n_workers=1 on <=2 CPU, nproc-1 (up to 8) otherwise.
Throughput baseline: ~1.1 Math tests/s serial on 2-core (unchanged; the
evaluator dominates). The runner framework is now ready to scale on bigger
machines without further code changes.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Mock `El` now exposes `dataset` as a Proxy that syncs property
writes back to `attributes["data-*"]`, and `setAttribute("data-*", ...)`
populates the backing dataset with camelCase key. That way
`#target.dataset.val = "new"` updates the `data-val` attribute,
letting the swap command read/write the property correctly.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Five parts: (a) tests/hs-run-filtered.js `io-wait-event` mock now
registers a one-shot listener on the target element and resumes with
the event, instead of immediately resuming with nil. (b) Added
hs-wait-for-or runtime form carrying a timeout-ms; mock resumes
immediately when a timeout is present (0ms tests). (c) parser
parse-wait-cmd recognises `wait for EV(v1, v2)` destructure syntax,
emits :destructure list on wait-for AST. (d) compiler emit-wait-for
updated for :from/:or combos; a new `__bind-from-detail__` form
compiles to `(define v (host-get (host-get it "detail") v))`, and the
`do`-sequence handler preprocesses wait-for to splice these synthetic
bindings after the wait. (e) generator extracts `detail: ...` from
`CustomEvent` options so dispatched events carry their payload.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
js-transpile-unop intercepts 'delete' before transpiling the
operand. Maps to (js-delete-prop obj key) for members and indexed
access. Runtime js-delete-prop sets the dict value to js-undefined
and returns true.
444/446 unit (+2), 148/148 slice unchanged.
Each prototype contains method-name → closure pairs. Each closure
reads this via js-this and dispatches through js-invoke-method.
Lets Array.prototype.push, String.prototype.slice etc. be accessed
and invoked as (expected) functions.
440/442 unit unchanged, 148/148 slice unchanged.
Array destructure now supports [a, ...rest]. Rest entry is
transpiled to (define name (js-list-slice tmp i (len tmp))).
Nested patterns like [[a,b], c] now parse (as holes) instead of
erroring. jp-skip-balanced skips nested groups.
440/442 unit (+2), 148/148 slice unchanged.
Parser: jp-parse-postfix handles op "?." followed by ident / [ / (
emitting (js-optchain-member obj name), (js-optchain-index obj k),
or (js-optchain-call callee args).
Transpile: each emits (js-optchain-get obj key) or (js-optchain-call
fn args).
Runtime: js-optchain-get and js-optchain-call short-circuit to
js-undefined when receiver is null/undefined.
423/425 unit (+5), 148/148 slice unchanged.
Three-part fix: (a) emit-send now builds detail=(dict "sender" me) on
(send NAME target) and bare (send NAME) instead of nil, so the receiving
handler has access to the sending element. (b) parser parse-atom now
recognises the `sender` keyword (previously swallowed as noise) and
emits it as (sender). (c) compiler translates bare `sender` symbol and
(sender) list-head to (hs-sender event) — a new runtime helper that
reads (get (host-get event "detail") "sender").
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Partial fix. The generator's block-form `evaluate(() => { ... })`
swallowed blocks that weren't window-setup assignments (e.g. `const e =
new Event(...); elem.dispatchEvent(e);`). It now only `continue`s when
at least one window-setup pair was parsed; otherwise falls through to
downstream patterns. Also added a new pattern that recognises the
`evaluate(() => { const e = new Event(...); document.querySelector(SEL)
.dispatchEvent(e); })` shape and emits a `dom-dispatch` op.
Still failing: "at start of", "in a element target", "in a symbol
write" — root cause here is that the inserted-button's hyperscript
handler still isn't activating in the afterbegin / innerHTML paths.
Tracked separately.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Parser: jp-array-loop and jp-call-args-loop detect punct "..."
and emit (js-spread inner).
Transpile: when any element is spread, build array/args via
js-array-spread-build with (list "js-value" v) and (list
"js-spread" xs) tags.
Runtime: js-array-spread-build walks items, appending values or
splicing spreads via js-iterable-to-list (handles list/string/dict).
Works in arrays, call args, variadic fns (Math.max(...arr)),
and string spread ([...'abc']).
414/416 unit (+5), 148/148 slice unchanged.
String: replace, search, match now work with either string or regex
arg. Regex path uses js-string-index-of on source (case-adjusted
when ignoreCase set).
Array.from(iter, mapFn?) normalizes via js-iterable-to-list and
optionally applies mapFn.
Fixed dict-set! on list bug in js-regex-stub-exec — just omit the
index/input metadata, spec-breaking but tests that just check [0]
work.
407/409 unit (+8), 148/148 slice unchanged.
`\$window.foo` / `\${window.foo}` couldn't resolve. Two fixes:
(a) compiler.sx: in a dot-chain base position, known globals (window,
document, navigator, location, history, screen, localStorage,
sessionStorage, console) emit `(host-global "name")` instead of a
bare unbound symbol.
(b) generator: `eval-hs-locals` now also sets each binding on
`window.<name>` via `host-set!`, so tests that translated
`window.X = Y` as a local pair still see `window.X` at eval time.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
