Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

11.8 KB
Raw Blame
use super::static_storage::{
    set_static_range_boundary, static_range_boundary_container_object, static_range_boundary_offset,
};
use super::*;
use crate::document_runtime::DomHandle;
use crate::native_bridge::{RangeBoundarySide, RangeRecordHandle};

pub(in crate::context_bootstrap) const RANGE_RECORD_LIFETIME_INTERNAL_FIELD_INDEX: usize = 0;
pub(in crate::context_bootstrap) const RANGE_RECORD_ID_INTERNAL_FIELD_INDEX: usize = 1;
pub(in crate::context_bootstrap) const RANGE_WRAPPER_INTERNAL_FIELD_COUNT: usize = 2;

pub(in crate::context_bootstrap) fn current_document_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
) -> Option<v8::Local<'s, v8::Object>> {
    let global = scope.get_current_context().global(scope);
    global
        .get(scope, v8str(scope, "document").into())
        .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
}

pub(in crate::context_bootstrap) fn new_range_for_document<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    document: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
    let global = scope.get_current_context().global(scope);
    let ctor = global.get(scope, v8str(scope, "Range").into())?;
    let ctor = v8::Local::<v8::Function>::try_from(ctor).ok()?;
    let range = ctor.new_instance(scope, &[])?;
    initialize_range_object(scope, range, document);
    Some(range)
}

pub(in crate::context_bootstrap) fn initialize_range_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    document: v8::Local<'s, v8::Object>,
) {
    if range.internal_field_count() < RANGE_WRAPPER_INTERNAL_FIELD_COUNT {
        return;
    }
    let existing_handle = range_native_record_handle(scope, range);
    initialize_native_range_record(scope, range, document, existing_handle);
}

// InputEvent stores live copies and exposes fresh StaticRanges. Use intrinsic
// templates and native boundary storage, without invoking author constructors
// or boundary getters.
pub(in crate::context_bootstrap) fn live_range_from_static_range<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    source: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
    let start = static_range_boundary_container_object(scope, source, RangeBoundarySide::Start)?;
    let end = static_range_boundary_container_object(scope, source, RangeBoundarySide::End)?;
    let start_offset = static_range_boundary_offset(scope, source, RangeBoundarySide::Start) as u32;
    let end_offset = static_range_boundary_offset(scope, source, RangeBoundarySide::End) as u32;
    let document = current_document_object(scope)?;
    let range =
        super::super::exposed_interfaces::build_intrinsic_interface_instance(scope, "Range")
            .ok()?;
    initialize_range_object(scope, range, document);
    super::super::range_surface::set_range_boundary_checked(
        scope,
        range,
        RangeBoundarySide::Start,
        start,
        start_offset,
    )?;
    super::super::range_surface::set_range_boundary_checked(
        scope,
        range,
        RangeBoundarySide::End,
        end,
        end_offset,
    )?;
    crate::web_api_interfaces::initialize(scope, range, "Range").ok()?;
    Some(range)
}

pub(in crate::context_bootstrap) fn static_range_snapshot<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    source: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
    let start = range_boundary_container_object(scope, source, RangeBoundarySide::Start)?;
    let end = range_boundary_container_object(scope, source, RangeBoundarySide::End)?;
    let start_offset = range_boundary_offset(scope, source, RangeBoundarySide::Start) as u32;
    let end_offset = range_boundary_offset(scope, source, RangeBoundarySide::End) as u32;
    let range =
        super::super::exposed_interfaces::build_intrinsic_interface_instance(scope, "StaticRange")
            .ok()?;
    super::static_storage::initialize_static_range_object(
        scope,
        range,
        start,
        start_offset,
        end,
        end_offset,
    );
    let prototype = super::super::exposed_interfaces::ensure_intrinsic_interface_prototype(
        scope,
        "StaticRange",
    )
    .ok()?;
    range.set_prototype(scope, prototype.into())?;
    crate::web_api_interfaces::initialize(scope, range, "StaticRange").ok()?;
    Some(range)
}

pub(in crate::context_bootstrap) fn set_range_boundary<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    side: RangeBoundarySide,
    container: v8::Local<'s, v8::Object>,
    offset: u32,
) {
    if set_native_range_record_boundary(scope, range, side, container, offset)
        || range_native_record_handle(scope, range).is_some()
    {
        return;
    }
    set_static_range_boundary(scope, range, side, container, offset);
}

pub(in crate::context_bootstrap) fn range_boundary_container_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    side: RangeBoundarySide,
) -> Option<v8::Local<'s, v8::Object>> {
    if let Some(native) = native_range_boundary_container_object(scope, range, side) {
        return Some(native);
    }
    static_range_boundary_container_object(scope, range, side)
}

pub(in crate::context_bootstrap) fn range_boundary_offset<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    side: RangeBoundarySide,
) -> f64 {
    if let Some(native) = native_range_boundary_offset(scope, range, side) {
        return native as f64;
    }
    static_range_boundary_offset(scope, range, side)
}

#[derive(Clone, Copy)]
pub(in crate::context_bootstrap) struct RangeBoundaryHandle {
    pub(in crate::context_bootstrap) container: DomHandle,
    pub(in crate::context_bootstrap) offset: u32,
}

#[derive(Clone, Copy)]
pub(in crate::context_bootstrap) struct RangeBoundaryHandles {
    pub(in crate::context_bootstrap) start: RangeBoundaryHandle,
    pub(in crate::context_bootstrap) end: RangeBoundaryHandle,
}

pub(in crate::context_bootstrap) fn native_range_boundary_handles<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
) -> Option<RangeBoundaryHandles> {
    let handle = range_native_record_handle(scope, range)?;
    let host_ptr = context_host_ptr_from_global_bridge(scope)?;
    let (start, end) = unsafe { &mut *host_ptr }.range_record_boundary_handles(handle)?;
    Some(RangeBoundaryHandles {
        start: RangeBoundaryHandle {
            container: start.0,
            offset: start.1,
        },
        end: RangeBoundaryHandle {
            container: end.0,
            offset: end.1,
        },
    })
}

pub(in crate::context_bootstrap) fn native_range_boundary_point<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    side: RangeBoundarySide,
) -> Option<crate::range_boundary::RangeBoundaryPoint> {
    let handle = range_native_record_handle(scope, range)?;
    let host_ptr = context_host_ptr_from_global_bridge(scope)?;
    unsafe { &*host_ptr }.range_record_boundary_point(handle, side)
}

fn initialize_native_range_record<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    document: v8::Local<'s, v8::Object>,
    existing_handle: Option<RangeRecordHandle>,
) {
    let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {
        return;
    };
    let Some(document_handle) = dom_handle_for_range_object(scope, host_ptr, document) else {
        return;
    };
    let handle = existing_handle
        .and_then(|handle| {
            unsafe { &mut *host_ptr }
                .reset_range_record(handle, document_handle)
                .then_some(handle)
        })
        .or_else(|| unsafe { &mut *host_ptr }.create_range_record(document_handle));
    if let Some(handle) = handle {
        set_range_native_record_handle_storage(scope, range, handle);
        unsafe { &mut *host_ptr }.register_live_range_record(scope, range, handle);
    }
}

pub(in crate::context_bootstrap) fn range_native_record_handle<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
) -> Option<RangeRecordHandle> {
    let lifetime_value =
        range.get_internal_field(scope, RANGE_RECORD_LIFETIME_INTERNAL_FIELD_INDEX)?;
    let lifetime_big = v8::Local::<v8::BigInt>::try_from(lifetime_value).ok()?;
    let (lifetime_token, lifetime_lossless) = lifetime_big.u64_value();
    if !lifetime_lossless {
        return None;
    }
    let id_value = range.get_internal_field(scope, RANGE_RECORD_ID_INTERNAL_FIELD_INDEX)?;
    let id_big = v8::Local::<v8::BigInt>::try_from(id_value).ok()?;
    let (id, id_lossless) = id_big.u64_value();
    id_lossless
        .then(|| RangeRecordHandle::new(lifetime_token, id))
        .flatten()
}

fn set_range_native_record_handle_storage<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    handle: RangeRecordHandle,
) {
    let lifetime = v8::BigInt::new_from_u64(scope, handle.lifetime_token());
    let _ = range.set_internal_field(RANGE_RECORD_LIFETIME_INTERNAL_FIELD_INDEX, lifetime.into());
    let id = v8::BigInt::new_from_u64(scope, handle.raw_id());
    let _ = range.set_internal_field(RANGE_RECORD_ID_INTERNAL_FIELD_INDEX, id.into());
}

fn native_range_boundary_container_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    side: RangeBoundarySide,
) -> Option<v8::Local<'s, v8::Object>> {
    let handle = range_native_record_handle(scope, range)?;
    let host_ptr = context_host_ptr_from_global_bridge(scope)?;
    let handle = unsafe { &*host_ptr }.range_record_boundary_container(handle, side)?;
    native_bridge::wrapped_handle_value(scope, host_ptr, handle)
        .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
}

fn native_range_boundary_offset<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    side: RangeBoundarySide,
) -> Option<u32> {
    let handle = range_native_record_handle(scope, range)?;
    let host_ptr = context_host_ptr_from_global_bridge(scope)?;
    unsafe { &mut *host_ptr }.range_record_boundary_offset(handle, side)
}

fn set_native_range_record_boundary<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
    side: RangeBoundarySide,
    container: v8::Local<'s, v8::Object>,
    offset: u32,
) -> bool {
    let Some(handle) = range_native_record_handle(scope, range) else {
        return false;
    };
    let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {
        return false;
    };
    let Some(container_handle) = dom_handle_for_range_object(scope, host_ptr, container) else {
        return false;
    };
    unsafe { &mut *host_ptr }.set_range_record_boundary(handle, side, container_handle, offset)
}

fn dom_handle_for_range_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    host_ptr: *mut JsContextHost,
    object: v8::Local<'s, v8::Object>,
) -> Option<DomHandle> {
    native_bridge::callback_value_dom_handle(scope, object.into()).or_else(|| {
        native_bridge::document::detached_native_handle_for_runtime(scope, host_ptr, object)
    })
}

pub(in crate::context_bootstrap) fn range_is_collapsed<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    range: v8::Local<'s, v8::Object>,
) -> bool {
    if let Some(handle) = range_native_record_handle(scope, range)
        && let Some(host_ptr) = context_host_ptr_from_global_bridge(scope)
        && let Some(collapsed) = unsafe { &mut *host_ptr }.range_record_is_collapsed(handle)
    {
        return collapsed;
    }
    let Some(start_container) =
        range_boundary_container_object(scope, range, RangeBoundarySide::Start)
    else {
        return true;
    };
    let Some(end_container) = range_boundary_container_object(scope, range, RangeBoundarySide::End)
    else {
        return true;
    };
    start_container.strict_equals(end_container.into())
        && (range_boundary_offset(scope, range, RangeBoundarySide::Start)
            == range_boundary_offset(scope, range, RangeBoundarySide::End))
}