from pulse.js import (
    AbortController,
    AbortSignal,
    Animation,
    Array,
    ArrayBuffer,
    BigInt64Array,
    BigUint64Array,
    Blob,
    CustomEvent,
    DataView,
    Date,
    DOMParser,
    DocumentTimeline,
    Error,
    File,
    FileReader,
    Float32Array,
    Float64Array,
    FormData,
    Headers,
    Int16Array,
    Int32Array,
    Int8Array,
    IntersectionObserver,
    KeyframeEffect,
    Map,
    MutationObserver,
    Number,
    Object,
    PerformanceObserver,
    Promise,
    RegExp,
    Request,
    ResizeObserver,
    Response,
    Set,
    String,
    TextDecoder,
    TextEncoder,
    Uint16Array,
    Uint32Array,
    Uint8Array,
    Uint8ClampedArray,
    URL,
    URLSearchParams,
    WeakMap,
    WeakSet,
    XMLSerializer,
)

from pulse.js import Array

@ps.javascript
def example():
    arr = Array(10)              # -> new Array(10)
    arr = Array(1, 2, 3)         # -> new Array(1, 2, 3)

from pulse.js import Array

@ps.javascript
def process_items(items):
    # Filter and map
    result = Array.from_(items).filter(
        lambda x, i, arr: x > 0
    ).map(
        lambda x, i, arr: x * 2
    )

    # Reduce
    total = result.reduce(lambda acc, x, i, arr: acc + x, 0)

    return total

from pulse.js import Date

@ps.javascript
def example():
    now = Date()                      # -> new Date()
    specific = Date("2024-01-15")     # -> new Date("2024-01-15")
    timestamp = Date.now()            # -> Date.now()

from pulse.js import Error, throw
from pulse.js.error import TypeError, RangeError, ReferenceError

@ps.javascript
def example():
    throw(Error("Something went wrong"))
    throw(TypeError("Expected a string"))

from pulse.js import Error, throw

@ps.javascript
def validate(value):
    if value < 0:
        throw(RangeError("Value must be non-negative"))
    return value

from pulse.js import Map

@ps.javascript
def example():
    m = Map()                         # -> new Map()
    m = Map([["a", 1], ["b", 2]])     # -> new Map([["a", 1], ["b", 2]])

from pulse.js import Map

@ps.javascript
def build_lookup(items):
    lookup = Map()
    for item in items:
        lookup.set(item.id, item)

    if lookup.has("abc"):
        return lookup.get("abc")
    return None

from pulse.js import Number

@ps.javascript
def example():
    Number.isFinite(42)           # -> Number.isFinite(42)
    Number.MAX_SAFE_INTEGER       # -> Number.MAX_SAFE_INTEGER

from pulse.js import Object

@ps.javascript
def example():
    keys = Object.keys(data)          # -> Object.keys(data)
    merged = Object.assign({}, a, b)  # -> Object.assign({}, a, b)

from pulse.js import Promise

@ps.javascript
async def example():
    result = await Promise.resolve(42)
    data = await fetch("/api/data")

Promise(lambda resolve, reject: ...)

@ps.javascript
async def fetch_data():
    response = await fetch("/api/data")
    data = await response.json()
    return data

from pulse.js import URL

@ps.javascript
def example():
    url = URL("https://example.com?foo=1#section")
    return url.href, url.searchParams.toString()

from pulse.js import URLSearchParams

@ps.javascript
def example():
    params = URLSearchParams("foo=1&bar=2")
    params.append("bar", "3")
    return params.toString()

from pulse.js import AbortController

@ps.javascript
def example():
    controller = AbortController()
    controller.abort()
    return controller.signal.aborted

from pulse.js import Headers, Request, fetch, obj

@ps.javascript
def example():
    headers = Headers()
    headers.set("Content-Type", "application/json")
    req = Request("/api", obj(method="POST", headers=headers, body="{}"))
    return fetch(req)

from pulse.js import FormData

@ps.javascript
def example():
    data = FormData()
    data.append("name", "Ada")
    return data.get("name")

from pulse.js import Blob, obj

@ps.javascript
def example():
    blob = Blob(["hello"], obj(type="text/plain"))
    return blob.size

from pulse.js import File, obj

@ps.javascript
def example():
    f = File(["hello"], "note.txt", obj(type="text/plain"))
    return f.name

from pulse.js import FileReader

@ps.javascript
def example(blob):
    reader = FileReader()
    reader.readAsText(blob)
    return reader.result

from pulse.js import TextEncoder, TextDecoder

@ps.javascript
def example(text: str):
    enc = TextEncoder()
    data = enc.encode(text)
    dec = TextDecoder("utf-8")
    return dec.decode(data)

from pulse.js import ArrayBuffer, Uint8Array

@ps.javascript
def example():
    buf = ArrayBuffer(8)
    view = Uint8Array(buf)
    return buf.byteLength, view.byteLength

from pulse.js import IntersectionObserver, obj

@ps.javascript
def example(target):
    observer = IntersectionObserver(lambda entries, obs: None, obj(threshold=0.5))
    observer.observe(target)

from pulse.js import ResizeObserver, obj

@ps.javascript
def example(target):
    observer = ResizeObserver(lambda entries, obs: None)
    observer.observe(target, obj(box="border-box"))

from pulse.js import PerformanceObserver, obj

@ps.javascript
def example():
    observer = PerformanceObserver(lambda list_, obs: None)
    observer.observe(obj(entryTypes=["mark", "measure"]))

from pulse.js import Animation, KeyframeEffect, document, obj

@ps.javascript
def fade_in(element):
    # Define what animates: target element, keyframes, and timing
    effect = KeyframeEffect(
        element,
        [obj(opacity=0), obj(opacity=1)],  # From invisible to visible
        obj(duration=300, easing="ease-out", fill="forwards"),
    )

    # Create and start the animation
    animation = Animation(effect, document.timeline)
    animation.play()
    return animation

effect = KeyframeEffect(
    target,                                    # Element to animate
    [obj(opacity=0), obj(opacity=1)],          # Keyframes (array of states)
    obj(duration=300, easing="ease-in-out"),   # Timing options
)

# Slide and fade in
[
    obj(opacity=0, transform="translateY(-20px)"),
    obj(opacity=1, transform="translateY(0)"),
]

# Bounce effect (multiple keyframes)
[
    obj(transform="scale(1)"),
    obj(transform="scale(1.2)"),
    obj(transform="scale(1)"),
]

animation = Animation(effect, document.timeline)
animation.play()  # Start it

@ps.javascript
async def animate_then_remove(element):
    effect = KeyframeEffect(
        element,
        [obj(opacity=1), obj(opacity=0)],
        obj(duration=200, fill="forwards"),
    )
    animation = Animation(effect, document.timeline)
    animation.play()

    # Wait for fade out to complete
    await animation.finished

    # Now safe to remove
    element.remove()

from pulse.js import DocumentTimeline

# Custom timeline with offset origin
timeline = DocumentTimeline(obj(originTime=1000))
animation = Animation(effect, timeline)

from pulse.js import DOMParser, XMLSerializer

@ps.javascript
def example(source: str):
    parser = DOMParser()
    doc = parser.parseFromString(source, "text/html")
    serializer = XMLSerializer()
    return serializer.serializeToString(doc)

from pulse.js import CustomEvent, obj

@ps.javascript
def example():
    event = CustomEvent("ping", obj(detail=obj(ok=True)))
    return event.detail

from pulse.js import MutationObserver, obj

@ps.javascript
def example(target):
    observer = MutationObserver(lambda records, obs: None)
    observer.observe(target, obj(childList=True, subtree=True))

from pulse.js import RegExp

@ps.javascript
def example():
    pattern = RegExp(r"\d+", "g")     # -> new RegExp("\\d+", "g")
    if pattern.test("abc123"):
        matches = pattern.exec("abc123")

from pulse.js import Set

@ps.javascript
def example():
    s = Set()                         # -> new Set()
    s = Set([1, 2, 3])                # -> new Set([1, 2, 3])

from pulse.js import String

@ps.javascript
def example():
    String.fromCharCode(65)           # -> String.fromCharCode(65) -> "A"
    String.fromCodePoint(0x1F600)     # -> String.fromCodePoint(0x1F600) -> emoji

from pulse.js import WeakMap

@ps.javascript
def example():
    cache = WeakMap()
    cache.set(obj, "value")

from pulse.js import WeakSet

@ps.javascript
def example():
    seen = WeakSet()
    seen.add(obj)

from pulse.js import obj

@ps.javascript
def example():
    style = obj(color="red", fontSize="14px")  # -> { color: "red", fontSize: "14px" }

    # With spread
    merged = obj(**base, newKey="value")       # -> { ...base, newKey: "value" }

from pulse.js import undefined

@ps.javascript
def example():
    if value is undefined:
        return "missing"

from pulse.js import throw, Error

@ps.javascript
def validate(x):
    if x < 0:
        throw(Error("Must be positive"))