Skip to content

armgit / moli

Public Imported from GitHub
0

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

15.2 KB
Raw Blame
use super::iterators::{FormDataIteratorKind, live_form_data_iterator};
use super::serialize::serialize_form_data_controls;
use super::storage::{
    form_data_entries, initialize_form_data_entries, mutate_form_data_entries,
    normalize_form_data_value, push_form_data_entry, set_form_data_entries,
};
use super::*;
use crate::{
    callback_invocation::invoke_synchronous_webidl_callback_function,
    native_bridge::{
        JsContextHost,
        element::{form_associated_form_owner, is_valid_submit_button},
        node_relevant_context, node_runtime_and_handle_from_object_or_detached,
        throw_dom_exception,
    },
    util::serialize_v8_iter_array,
    web_api_interfaces, webidl,
};
use moli_webapi_declare::WebApiObject;

#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct FormDataEventInitDeclaration<'scope> {
    form_data: v8::Local<'scope, v8::Object>,
    bubbles: bool,
    cancelable: bool,
}

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "FormData")]
struct FormDataConstructorArgs<'s> {
    #[webidl(interface = web_api_interfaces::HTMLFormElement)]
    form: Option<v8::Local<'s, v8::Object>>,
    #[webidl(index = 1, nullable, interface = web_api_interfaces::HTMLElement)]
    submitter: Option<v8::Local<'s, v8::Object>>,
}

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "FormData")]
struct FormDataNameArgs {
    #[webidl(required, converter = "usv_string")]
    name: String,
}

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "FormData")]
struct FormDataMutationArgs<'s> {
    #[webidl(required, converter = "usv_string")]
    name: String,
    #[webidl(required)]
    value: v8::Local<'s, v8::Value>,
    #[webidl(index = 2, converter = "raw")]
    filename: Option<v8::Local<'s, v8::Value>>,
}

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "FormData.forEach")]
struct FormDataForEachArgs<'s> {
    #[webidl(
        required,
        converter = "callback_function",
        missing_message = "FormData.forEach requires a callback"
    )]
    callback: webidl::WebIdlCallbackFunction,
    this_arg: Option<v8::Local<'s, v8::Value>>,
}

fn require_form_data_receiver<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: &v8::FunctionCallbackArguments<'s>,
    method: &'static str,
) -> Option<v8::Local<'s, v8::Object>> {
    let object = args.this();
    if !form_data_is_object(scope, object) {
        throw_type_error(
            scope,
            &format!("Failed to execute '{method}' on 'FormData': Illegal invocation."),
        );
        return None;
    }
    Some(object)
}

fn form_data_value_arg<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    value: v8::Local<'s, v8::Value>,
    filename: Option<v8::Local<'s, v8::Value>>,
    method: &'static str,
) -> Option<v8::Local<'s, v8::Value>> {
    normalize_form_data_value(
        scope,
        value,
        filename,
        webidl::Context::argument(method, 2),
        webidl::Context::argument(method, 3),
    )
    .map_or_else(
        |error| {
            webidl::throw_error(scope, &error);
            None
        },
        Some,
    )
}

pub(super) fn form_data_constructor_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    if !args.is_construct_call() {
        throw_type_error(
            scope,
            "Failed to construct 'FormData': Please use the 'new' operator.",
        );
        return;
    }

    let Some(parsed) = webidl::parse_args::<FormDataConstructorArgs<'s>>(scope, &args) else {
        return;
    };
    let submitter = parsed.submitter;
    let mut entries = Vec::new();
    if let Some(form) = parsed.form {
        let Ok((form_runtime_ptr, form_handle)) =
            node_runtime_and_handle_from_object_or_detached(scope, form)
        else {
            throw_type_error(scope, "FormData constructor requires an HTMLFormElement");
            return;
        };
        if let Some(submitter) = submitter {
            let Ok((submitter_runtime_ptr, submitter_handle)) =
                node_runtime_and_handle_from_object_or_detached(scope, submitter)
            else {
                throw_type_error(
                    scope,
                    "FormData constructor submitter must be a submit button",
                );
                return;
            };
            let runtime = unsafe { &*submitter_runtime_ptr };
            if !is_valid_submit_button(runtime, submitter_handle) {
                throw_type_error(
                    scope,
                    "FormData constructor submitter must be a submit button",
                );
                return;
            }
            if submitter_runtime_ptr != form_runtime_ptr
                || form_associated_form_owner(runtime, submitter_handle) != Some(form_handle)
            {
                throw_dom_exception(
                    scope,
                    "NotFoundError",
                    8,
                    "The specified element is not owned by this form element.",
                );
                return;
            }
        }
        let Some(next_entries) = construct_form_data_entries_for_form(
            scope,
            form_runtime_ptr,
            form_handle,
            form,
            submitter,
        ) else {
            return;
        };
        entries = next_entries;
    }
    let form_data = args.this();
    initialize_form_data_entries(scope, form_data, &entries);
    rv.set(form_data.into());
}

pub(crate) fn construct_form_data_entries_for_form<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    runtime_ptr: *mut JsContextHost,
    form_handle: crate::document_runtime::DomHandle,
    form: v8::Local<'s, v8::Object>,
    submitter: Option<v8::Local<'s, v8::Object>>,
) -> Option<Vec<(String, v8::Global<v8::Value>)>> {
    if !unsafe { &mut *runtime_ptr }.begin_form_data_construction(form_handle) {
        throw_dom_exception(
            scope,
            "InvalidStateError",
            11,
            "Cannot construct FormData while the form data set is already being constructed.",
        );
        return None;
    }

    let context = node_relevant_context(scope, form).unwrap_or_else(|| scope.get_current_context());
    let scope = &mut v8::ContextScope::new(scope, context);
    let entries = serialize_form_data_controls(scope, runtime_ptr, form_handle, submitter);
    let entries = dispatch_form_data_event_with_entries(scope, form, &entries).unwrap_or(entries);
    unsafe { &mut *runtime_ptr }.end_form_data_construction(form_handle);
    Some(entries)
}

fn dispatch_form_data_event_with_entries<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    form: v8::Local<'s, v8::Object>,
    entries: &[(String, v8::Global<v8::Value>)],
) -> Option<Vec<(String, v8::Global<v8::Value>)>> {
    let form_data = new_empty_form_data_object(scope)?;
    set_form_data_entries(scope, form_data, entries);
    dispatch_form_data_event(scope, form, form_data);
    Some(form_data_entries(scope, form_data))
}

fn new_empty_form_data_object<'s>(
    scope: &mut v8::PinScope<'s, '_>,
) -> Option<v8::Local<'s, v8::Object>> {
    let global = scope.get_current_context().global(scope);
    let constructor = global
        .get(scope, v8str(scope, "FormData").into())
        .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())?;
    constructor.new_instance(scope, &[])
}

fn dispatch_form_data_event<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    form: v8::Local<'s, v8::Object>,
    form_data: v8::Local<'s, v8::Object>,
) {
    let Ok((runtime_ptr, form_handle)) =
        node_runtime_and_handle_from_object_or_detached(scope, form)
    else {
        return;
    };
    let Some(event) = new_form_data_event(scope, form_data) else {
        return;
    };
    crate::context_bootstrap::events::mark_event_trusted(scope, event);
    let _ = crate::native_bridge::element::dispatch_public_event(
        scope,
        runtime_ptr,
        form_handle,
        event,
    );
}

fn new_form_data_event<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    form_data: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
    let global = scope.get_current_context().global(scope);
    let constructor = global
        .get(scope, v8str(scope, "FormDataEvent").into())
        .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())?;
    let init = FormDataEventInitDeclaration::new(form_data, true, false)
        .bind(scope)
        .expect("FormDataEvent init declaration should bind");
    let event_type = v8str(scope, "formdata");
    constructor.new_instance(scope, &[event_type.into(), init.into()])
}

pub(super) fn form_data_append_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "append") else {
        return;
    };
    let Some(parsed) = webidl::parse_args::<FormDataMutationArgs>(scope, &args) else {
        return;
    };
    let Some(value) = form_data_value_arg(scope, parsed.value, parsed.filename, "FormData.append")
    else {
        return;
    };
    let value = v8::Global::new(scope, value);
    mutate_form_data_entries(scope, object, |entries| {
        push_form_data_entry(entries, &parsed.name, value);
    });
    rv.set_undefined();
}

pub(super) fn form_data_set_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "set") else {
        return;
    };
    let Some(parsed) = webidl::parse_args::<FormDataMutationArgs>(scope, &args) else {
        return;
    };
    let Some(value) = form_data_value_arg(scope, parsed.value, parsed.filename, "FormData.set")
    else {
        return;
    };
    let value = v8::Global::new(scope, value);
    mutate_form_data_entries(scope, object, |entries| {
        let mut value = Some(value);
        let mut did_replace = false;
        entries.retain_mut(|(key, entry_value)| {
            if *key != parsed.name {
                return true;
            }
            if !did_replace {
                *entry_value = value
                    .take()
                    .expect("first matching FormData entry should receive replacement value");
                did_replace = true;
                return true;
            }
            false
        });
        if let Some(value) = value {
            push_form_data_entry(entries, &parsed.name, value);
        }
    });
    rv.set_undefined();
}

pub(super) fn form_data_get_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "get") else {
        return;
    };
    let Some(parsed) = webidl::parse_args::<FormDataNameArgs>(scope, &args) else {
        return;
    };
    for (key, value) in form_data_entries(scope, object) {
        if key == parsed.name {
            rv.set(v8::Local::new(scope, &value));
            return;
        }
    }
    rv.set_null();
}

pub(super) fn form_data_get_all_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "getAll") else {
        return;
    };
    let Some(parsed) = webidl::parse_args::<FormDataNameArgs>(scope, &args) else {
        return;
    };
    let entries = form_data_entries(scope, object);
    let values = entries
        .into_iter()
        .filter_map(|(key, value)| (key == parsed.name).then(|| v8::Local::new(scope, &value)))
        .collect::<Vec<_>>();
    let array = serialize_v8_iter_array(scope, values).unwrap_or_else(|| v8::Array::new(scope, 0));
    rv.set(array.into());
}

pub(super) fn form_data_has_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "has") else {
        return;
    };
    let Some(parsed) = webidl::parse_args::<FormDataNameArgs>(scope, &args) else {
        return;
    };
    let entries = form_data_entries(scope, object);
    let present = entries.iter().any(|(key, _)| *key == parsed.name);
    rv.set(v8::Boolean::new(scope, present).into());
}

pub(super) fn form_data_delete_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "delete") else {
        return;
    };
    let Some(parsed) = webidl::parse_args::<FormDataNameArgs>(scope, &args) else {
        return;
    };
    mutate_form_data_entries(scope, object, |entries| {
        entries.retain(|(key, _)| *key != parsed.name);
    });
    rv.set_undefined();
}

pub(super) fn form_data_keys_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "keys") else {
        return;
    };
    if let Some(iter) = live_form_data_iterator(scope, object, FormDataIteratorKind::Keys) {
        rv.set(iter);
    } else {
        rv.set(v8::undefined(scope).into());
    }
}

pub(super) fn form_data_values_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "values") else {
        return;
    };
    if let Some(iter) = live_form_data_iterator(scope, object, FormDataIteratorKind::Values) {
        rv.set(iter);
    } else {
        rv.set(v8::undefined(scope).into());
    }
}

pub(super) fn form_data_entries_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "entries") else {
        return;
    };
    if let Some(iter) = live_form_data_iterator(scope, object, FormDataIteratorKind::Entries) {
        rv.set(iter);
    } else {
        rv.set(v8::undefined(scope).into());
    }
}

pub(super) fn form_data_for_each_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let Some(object) = require_form_data_receiver(scope, &args, "forEach") else {
        return;
    };
    let Some(parsed) = webidl::parse_args::<FormDataForEachArgs>(scope, &args) else {
        return;
    };
    let this_arg = parsed
        .this_arg
        .unwrap_or_else(|| v8::undefined(scope).into());
    let callback = parsed.callback.prepare(scope);
    let mut index = 0;
    loop {
        let entries = form_data_entries(scope, object);
        let Some((key, value)) = entries.get(index) else {
            break;
        };
        index += 1;
        let Some(key) = v8_string(scope, key) else {
            continue;
        };
        let value = v8::Local::new(scope, value);
        if invoke_synchronous_webidl_callback_function(
            scope,
            &callback,
            this_arg,
            &[value, key.into(), object.into()],
        )
        .is_none()
        {
            return;
        }
    }
    rv.set_undefined();
}