Files
moli/moli-webapi/src/webidl_iterator.rs
T
ldm0 2d76938f9d feat(webmidi): add native frontend bindings and readonly maps
Expose secure MIDI requests, native receiver validation, port interface members,
and live readonly maplike operations. Reuse shared WebIDL dictionary, sequence,
callback and octet conversions. Device requests and port I/O reject explicitly
until a platform MIDI backend is available.
2026-11-21 20:03:31 +08:00

695 lines
26 KiB
Rust

use crate::callbacks::invoke_synchronous_webidl_callback_function;
use crate::interfaces as web_api_interfaces;
use anyhow::{Result, anyhow};
use moli_v8_util::{
get_private_object, get_private_value, materialize_hidden_function_template_prototype,
set_private_value, throw_type_error, v8str,
};
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject, v8};
use moli_webidl as webidl;
const SNAPSHOT_ITERATOR_VALUES_SLOT: &str = "__moliWebIdlIteratorValues";
const SNAPSHOT_ITERATOR_INDEX_SLOT: &str = "__moliWebIdlIteratorIndex";
const NATIVE_COLLECTION_ITERATOR_SLOT: &str = "__moliWebIdlNativeCollectionIterator";
const NATIVE_COLLECTION_ITERATOR_NEXT_SLOT: &str = "__moliWebIdlNativeCollectionIteratorNext";
const NATIVE_SET_ENTRIES_INTRINSIC_SLOT: &str = "__moliSetEntriesIntrinsic";
const NATIVE_SET_KEYS_INTRINSIC_SLOT: &str = "__moliSetKeysIntrinsic";
const NATIVE_SET_VALUES_INTRINSIC_SLOT: &str = "__moliSetValuesIntrinsic";
const NATIVE_SET_ITERATOR_NEXT_INTRINSIC_SLOT: &str = "__moliSetIteratorNextIntrinsic";
const NATIVE_REFLECT_APPLY_INTRINSIC_SLOT: &str = "__moliReflectApplyIntrinsic";
const NATIVE_REFLECT_CONSTRUCT_INTRINSIC_SLOT: &str = "__moliReflectConstructIntrinsic";
const NATIVE_MAP_ENTRIES_INTRINSIC_SLOT: &str = "__moliMapEntriesIntrinsic";
const NATIVE_MAP_KEYS_INTRINSIC_SLOT: &str = "__moliMapKeysIntrinsic";
const NATIVE_MAP_VALUES_INTRINSIC_SLOT: &str = "__moliMapValuesIntrinsic";
const NATIVE_MAP_ITERATOR_NEXT_INTRINSIC_SLOT: &str = "__moliMapIteratorNextIntrinsic";
const STYLE_PROPERTY_MAP_ITERATOR_PROTOTYPE_SLOT: &str = "__moliStylePropertyMapIteratorPrototype";
const EVENT_COUNTS_ITERATOR_PROTOTYPE_SLOT: &str = "__moliEventCountsIteratorPrototype";
const FONT_FACE_SET_ITERATOR_PROTOTYPE_SLOT: &str = "__moliFontFaceSetIteratorPrototype";
const VIEW_TRANSITION_TYPE_SET_ITERATOR_PROTOTYPE_SLOT: &str =
"__moliViewTransitionTypeSetIteratorPrototype";
const CUSTOM_STATE_SET_ITERATOR_PROTOTYPE_SLOT: &str = "__moliCustomStateSetIteratorPrototype";
const CSS_FONT_FEATURE_VALUES_MAP_ITERATOR_PROTOTYPE_SLOT: &str =
"__moliCssFontFeatureValuesMapIteratorPrototype";
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SnapshotWebIdlIteratorKind {
StylePropertyMapReadOnly,
EventCounts,
FontFaceSet,
CssFontFeatureValuesMap,
}
impl SnapshotWebIdlIteratorKind {
const fn interface(self) -> &'static str {
match self {
Self::StylePropertyMapReadOnly => "StylePropertyMapReadOnly Iterator",
Self::EventCounts => "EventCounts Iterator",
Self::FontFaceSet => "FontFaceSet Iterator",
Self::CssFontFeatureValuesMap => "CSSFontFeatureValuesMap Iterator",
}
}
const fn prototype_slot(self) -> &'static str {
match self {
Self::StylePropertyMapReadOnly => STYLE_PROPERTY_MAP_ITERATOR_PROTOTYPE_SLOT,
Self::EventCounts => EVENT_COUNTS_ITERATOR_PROTOTYPE_SLOT,
Self::FontFaceSet => FONT_FACE_SET_ITERATOR_PROTOTYPE_SLOT,
Self::CssFontFeatureValuesMap => CSS_FONT_FEATURE_VALUES_MAP_ITERATOR_PROTOTYPE_SLOT,
}
}
fn build_template<'s>(
self,
scope: &mut v8::PinScope<'s, '_, ()>,
) -> v8::Local<'s, v8::FunctionTemplate> {
match self {
Self::StylePropertyMapReadOnly => {
StylePropertyMapReadOnlyIteratorPrototypeDeclaration::build(scope)
}
Self::EventCounts => EventCountsIteratorPrototypeDeclaration::build(scope),
Self::FontFaceSet => FontFaceSetIteratorPrototypeDeclaration::build(scope),
Self::CssFontFeatureValuesMap => {
CssFontFeatureValuesMapIteratorPrototypeDeclaration::build(scope)
}
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SetlikeWebIdlIteratorKind {
ViewTransitionTypeSet,
CustomStateSet,
}
impl SetlikeWebIdlIteratorKind {
const fn interface(self) -> &'static str {
match self {
Self::ViewTransitionTypeSet => "ViewTransitionTypeSet Iterator",
Self::CustomStateSet => "CustomStateSet Iterator",
}
}
const fn prototype_slot(self) -> &'static str {
match self {
Self::ViewTransitionTypeSet => VIEW_TRANSITION_TYPE_SET_ITERATOR_PROTOTYPE_SLOT,
Self::CustomStateSet => CUSTOM_STATE_SET_ITERATOR_PROTOTYPE_SLOT,
}
}
fn build_template<'s>(
self,
scope: &mut v8::PinScope<'s, '_, ()>,
) -> v8::Local<'s, v8::FunctionTemplate> {
match self {
Self::ViewTransitionTypeSet => {
ViewTransitionTypeSetIteratorPrototypeDeclaration::build(scope)
}
Self::CustomStateSet => CustomStateSetIteratorPrototypeDeclaration::build(scope),
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SetlikeWebIdlIteratorMethod {
Entries,
Keys,
Values,
}
impl SetlikeWebIdlIteratorMethod {
const fn intrinsic_slot(self) -> &'static str {
match self {
Self::Entries => NATIVE_SET_ENTRIES_INTRINSIC_SLOT,
Self::Keys => NATIVE_SET_KEYS_INTRINSIC_SLOT,
Self::Values => NATIVE_SET_VALUES_INTRINSIC_SLOT,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MaplikeWebIdlIteratorMethod {
Entries,
Keys,
Values,
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct SnapshotWebIdlIteratorDeclaration<'s> {
#[webapi(slot = SNAPSHOT_ITERATOR_VALUES_SLOT)]
values: v8::Local<'s, v8::Array>,
#[webapi(slot = SNAPSHOT_ITERATOR_INDEX_SLOT)]
index: i32,
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct NativeCollectionWebIdlIteratorDeclaration<'s> {
#[webapi(slot = NATIVE_COLLECTION_ITERATOR_SLOT)]
iterator: v8::Local<'s, v8::Object>,
#[webapi(slot = NATIVE_COLLECTION_ITERATOR_NEXT_SLOT)]
next: v8::Local<'s, v8::Function>,
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct SnapshotWebIdlIteratorResultDeclaration<'s> {
value: v8::Local<'s, v8::Value>,
done: bool,
}
#[derive(WebApiFunctionTemplate)]
#[webapi(
interface = web_api_interfaces::StylePropertyMapReadOnlyIterator,
intrinsic_prototype_parent = v8::Intrinsic::IteratorPrototype,
prototype_to_string_tag = "StylePropertyMapReadOnly Iterator",
readonly_prototype,
enumerable
)]
struct StylePropertyMapReadOnlyIteratorPrototypeDeclaration {
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
next: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(
interface = web_api_interfaces::EventCountsIterator,
intrinsic_prototype_parent = v8::Intrinsic::MapIteratorPrototype,
prototype_to_string_tag = "EventCounts Iterator",
readonly_prototype,
enumerable
)]
struct EventCountsIteratorPrototypeDeclaration {
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
next: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(
interface = web_api_interfaces::FontFaceSetIterator,
intrinsic_prototype_parent = v8::Intrinsic::SetIteratorPrototype,
prototype_to_string_tag = "FontFaceSet Iterator",
readonly_prototype,
enumerable
)]
struct FontFaceSetIteratorPrototypeDeclaration {
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
next: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(
interface = web_api_interfaces::ViewTransitionTypeSetIterator,
intrinsic_prototype_parent = v8::Intrinsic::SetIteratorPrototype,
prototype_to_string_tag = "ViewTransitionTypeSet Iterator",
readonly_prototype,
enumerable
)]
struct ViewTransitionTypeSetIteratorPrototypeDeclaration {
#[webapi(
method,
length = 0,
callback = native_collection_webidl_iterator_next_callback
)]
next: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(
interface = web_api_interfaces::CustomStateSetIterator,
intrinsic_prototype_parent = v8::Intrinsic::SetIteratorPrototype,
prototype_to_string_tag = "CustomStateSet Iterator",
readonly_prototype,
enumerable
)]
struct CustomStateSetIteratorPrototypeDeclaration {
#[webapi(
method,
length = 0,
callback = native_collection_webidl_iterator_next_callback
)]
next: (),
}
#[derive(WebApiFunctionTemplate)]
#[webapi(
interface = web_api_interfaces::CSSFontFeatureValuesMapIterator,
intrinsic_prototype_parent = v8::Intrinsic::MapIteratorPrototype,
prototype_to_string_tag = "CSSFontFeatureValuesMap Iterator",
readonly_prototype,
enumerable
)]
struct CssFontFeatureValuesMapIteratorPrototypeDeclaration {
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
next: (),
}
pub fn install_webidl_collection_iterator_intrinsics<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
) -> Result<()> {
let set = v8::Set::new(scope);
let prototype = set
.get_prototype(scope)
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Set prototype"))?;
for (name, slot) in [
("entries", NATIVE_SET_ENTRIES_INTRINSIC_SLOT),
("keys", NATIVE_SET_KEYS_INTRINSIC_SLOT),
("values", NATIVE_SET_VALUES_INTRINSIC_SLOT),
] {
let function = prototype
.get(scope, v8str(scope, name).into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Set.prototype.{name}"))?;
set_private_value(scope, global, slot, function.into());
}
let values = native_collection_intrinsic(scope, NATIVE_SET_VALUES_INTRINSIC_SLOT)
.ok_or_else(|| anyhow!("missing captured intrinsic Set.prototype.values"))?;
let iterator = values
.call(scope, set.into(), &[])
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.ok_or_else(|| anyhow!("failed to create intrinsic Set iterator"))?;
let iterator_prototype = iterator
.get_prototype(scope)
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Set iterator prototype"))?;
let next = iterator_prototype
.get(scope, v8str(scope, "next").into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Set iterator next"))?;
set_private_value(
scope,
global,
NATIVE_SET_ITERATOR_NEXT_INTRINSIC_SLOT,
next.into(),
);
let reflect = global
.get(scope, v8str(scope, "Reflect").into())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Reflect object"))?;
for (name, slot) in [
("apply", NATIVE_REFLECT_APPLY_INTRINSIC_SLOT),
("construct", NATIVE_REFLECT_CONSTRUCT_INTRINSIC_SLOT),
] {
let function = reflect
.get(scope, v8str(scope, name).into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Reflect.{name}"))?;
set_private_value(scope, global, slot, function.into());
}
let map = v8::Map::new(scope);
let prototype = map
.get_prototype(scope)
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Map prototype"))?;
for (name, slot) in [
("entries", NATIVE_MAP_ENTRIES_INTRINSIC_SLOT),
("keys", NATIVE_MAP_KEYS_INTRINSIC_SLOT),
("values", NATIVE_MAP_VALUES_INTRINSIC_SLOT),
] {
let function = prototype
.get(scope, v8str(scope, name).into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Map.prototype.{name}"))?;
set_private_value(scope, global, slot, function.into());
}
let entries = native_collection_intrinsic(scope, NATIVE_MAP_ENTRIES_INTRINSIC_SLOT)
.ok_or_else(|| anyhow!("missing captured Map.prototype.entries"))?;
let iterator = entries
.call(scope, map.into(), &[])
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.ok_or_else(|| anyhow!("failed to create intrinsic Map iterator"))?;
let next = iterator
.get(scope, v8str(scope, "next").into())
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
.ok_or_else(|| anyhow!("missing intrinsic Map iterator next"))?;
set_private_value(
scope,
global,
NATIVE_MAP_ITERATOR_NEXT_INTRINSIC_SLOT,
next.into(),
);
Ok(())
}
pub fn webidl_collection_reflect_apply_intrinsic<'s>(
scope: &mut v8::PinScope<'s, '_>,
) -> Option<v8::Local<'s, v8::Function>> {
native_collection_intrinsic(scope, NATIVE_REFLECT_APPLY_INTRINSIC_SLOT)
}
pub fn reflect_construct_intrinsic<'s>(
scope: &mut v8::PinScope<'s, '_>,
) -> Option<v8::Local<'s, v8::Function>> {
native_collection_intrinsic(scope, NATIVE_REFLECT_CONSTRUCT_INTRINSIC_SLOT)
}
pub fn new_snapshot_webidl_iterator<'s>(
scope: &mut v8::PinScope<'s, '_>,
values: v8::Local<'s, v8::Array>,
kind: SnapshotWebIdlIteratorKind,
) -> Option<v8::Local<'s, v8::Object>> {
let iterator = SnapshotWebIdlIteratorDeclaration::new(values, 0)
.bind(scope)
.ok()?;
web_api_interfaces::initialize(scope, iterator, kind.interface()).ok()?;
let prototype = snapshot_webidl_iterator_prototype(scope, kind)?;
(iterator.set_prototype(scope, prototype.into()) == Some(true)).then_some(iterator)
}
pub fn new_setlike_webidl_iterator<'s>(
scope: &mut v8::PinScope<'s, '_>,
set: v8::Local<'s, v8::Set>,
kind: SetlikeWebIdlIteratorKind,
method: SetlikeWebIdlIteratorMethod,
) -> Option<v8::Local<'s, v8::Object>> {
let (native_iterator, next) = new_native_set_iterator(scope, set, method)?;
let iterator = NativeCollectionWebIdlIteratorDeclaration::new(native_iterator, next)
.bind(scope)
.ok()?;
web_api_interfaces::initialize(scope, iterator, kind.interface()).ok()?;
let prototype = setlike_webidl_iterator_prototype(scope, kind)?;
(iterator.set_prototype(scope, prototype.into()) == Some(true)).then_some(iterator)
}
pub fn call_setlike_webidl_for_each<'s>(
scope: &mut v8::PinScope<'s, '_>,
set: v8::Local<'s, v8::Set>,
owner: v8::Local<'s, v8::Object>,
callback: v8::Local<'s, v8::Value>,
this_arg: v8::Local<'s, v8::Value>,
operation: &'static str,
) -> Option<v8::Local<'s, v8::Value>> {
let callback = prepare_webidl_collection_for_each_callback(scope, callback, operation)?;
// A captured intrinsic Set iterator has the same live backing-list
// behavior as Set.prototype.forEach without manufacturing a second
// JavaScript callback to forward into the page callback.
let (iterator, next) =
new_native_set_iterator(scope, set, SetlikeWebIdlIteratorMethod::Values)?;
loop {
let value = match advance_native_collection_iterator(scope, iterator, next)? {
NativeCollectionIteratorStep::Done => break,
NativeCollectionIteratorStep::Value(value) => value,
};
invoke_webidl_collection_for_each_callback(
scope, &callback, this_arg, value, value, owner,
)?;
}
Some(v8::undefined(scope).into())
}
pub fn new_maplike_webidl_iterator<'s>(
scope: &mut v8::PinScope<'s, '_>,
map: v8::Local<'s, v8::Map>,
method: MaplikeWebIdlIteratorMethod,
) -> Option<v8::Local<'s, v8::Object>> {
let entries = map.as_array(scope);
let mut values = Vec::with_capacity(map.size());
for index in 0..map.size().min(u32::MAX as usize) as u32 {
let key = entries.get_index(scope, index.saturating_mul(2))?;
let value = entries.get_index(scope, index.saturating_mul(2).saturating_add(1))?;
values.push(match method {
MaplikeWebIdlIteratorMethod::Entries => {
v8::Array::new_with_elements(scope, &[key, value]).into()
}
MaplikeWebIdlIteratorMethod::Keys => key,
MaplikeWebIdlIteratorMethod::Values => value,
});
}
let values = v8::Array::new_with_elements(scope, &values);
new_snapshot_webidl_iterator(
scope,
values,
SnapshotWebIdlIteratorKind::CssFontFeatureValuesMap,
)
}
/// Live maplike iteration for device collections. CSS's existing snapshot
/// iterator has a separate residence policy and is deliberately unchanged.
pub fn new_live_maplike_webidl_iterator<'s>(
scope: &mut v8::PinScope<'s, '_>,
map: v8::Local<'s, v8::Map>,
method: MaplikeWebIdlIteratorMethod,
) -> Option<v8::Local<'s, v8::Object>> {
// WebIDL maplike declarations use %MapIteratorPrototype% directly.
// Captured intrinsic methods create the correct live iterator in the
// callee realm without consulting the author's Map prototype methods.
new_native_map_iterator(scope, map, method).map(|(iterator, _)| iterator)
}
pub fn call_live_maplike_webidl_for_each<'s>(
scope: &mut v8::PinScope<'s, '_>,
map: v8::Local<'s, v8::Map>,
owner: v8::Local<'s, v8::Object>,
callback: v8::Local<'s, v8::Value>,
this_arg: v8::Local<'s, v8::Value>,
operation: &'static str,
) -> Option<v8::Local<'s, v8::Value>> {
let callback = prepare_webidl_collection_for_each_callback(scope, callback, operation)?;
let (iterator, next) =
new_native_map_iterator(scope, map, MaplikeWebIdlIteratorMethod::Entries)?;
loop {
let entry = match advance_native_collection_iterator(scope, iterator, next)? {
NativeCollectionIteratorStep::Done => break,
NativeCollectionIteratorStep::Value(value) => {
v8::Local::<v8::Array>::try_from(value).ok()?
}
};
let key = entry.get_index(scope, 0)?;
let value = entry.get_index(scope, 1)?;
invoke_webidl_collection_for_each_callback(scope, &callback, this_arg, value, key, owner)?;
}
Some(v8::undefined(scope).into())
}
fn new_native_map_iterator<'s>(
scope: &mut v8::PinScope<'s, '_>,
map: v8::Local<'s, v8::Map>,
method: MaplikeWebIdlIteratorMethod,
) -> Option<(v8::Local<'s, v8::Object>, v8::Local<'s, v8::Function>)> {
let slot = match method {
MaplikeWebIdlIteratorMethod::Entries => NATIVE_MAP_ENTRIES_INTRINSIC_SLOT,
MaplikeWebIdlIteratorMethod::Keys => NATIVE_MAP_KEYS_INTRINSIC_SLOT,
MaplikeWebIdlIteratorMethod::Values => NATIVE_MAP_VALUES_INTRINSIC_SLOT,
};
let intrinsic = native_collection_intrinsic(scope, slot)?;
let iterator = intrinsic
.call(scope, map.into(), &[])
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())?;
let next = native_collection_intrinsic(scope, NATIVE_MAP_ITERATOR_NEXT_INTRINSIC_SLOT)?;
Some((iterator, next))
}
pub fn call_maplike_webidl_for_each<'s>(
scope: &mut v8::PinScope<'s, '_>,
map: v8::Local<'s, v8::Map>,
owner: v8::Local<'s, v8::Object>,
callback: v8::Local<'s, v8::Value>,
this_arg: v8::Local<'s, v8::Value>,
operation: &'static str,
) -> Option<v8::Local<'s, v8::Value>> {
let callback = prepare_webidl_collection_for_each_callback(scope, callback, operation)?;
// CSSFontFeatureValuesMap currently defines its iteration residence as
// this surface-owned snapshot. Callback migration must not silently turn
// that separate collection policy into a live iterator.
let entries = map.as_array(scope);
for index in 0..map.size().min(u32::MAX as usize) as u32 {
let key = entries.get_index(scope, index.saturating_mul(2))?;
let value = entries.get_index(scope, index.saturating_mul(2).saturating_add(1))?;
invoke_webidl_collection_for_each_callback(scope, &callback, this_arg, value, key, owner)?;
}
Some(v8::undefined(scope).into())
}
pub fn prepare_webidl_collection_for_each_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
callback: v8::Local<'s, v8::Value>,
operation: &'static str,
) -> Option<webidl::PreparedWebIdlCallbackFunction> {
// Generated maplike/setlike forEach is normatively IsCallable + Call,
// rather than an IDL Function argument. The strong callback-function
// value is an equivalent V8 ownership representation: it preserves
// callable proxies and context anchors, but owns no collection policy.
match webidl::convert::<webidl::WebIdlCallbackFunction>(
scope,
callback,
webidl::Context::argument(operation, 1),
) {
Ok(callback) => Some(callback.prepare(scope)),
Err(error) => {
webidl::throw_error(scope, &error);
None
}
}
}
pub fn invoke_webidl_collection_for_each_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
callback: &webidl::PreparedWebIdlCallbackFunction,
this_arg: v8::Local<'s, v8::Value>,
value: v8::Local<'s, v8::Value>,
key: v8::Local<'s, v8::Value>,
owner: v8::Local<'s, v8::Object>,
) -> Option<()> {
let _ = invoke_synchronous_webidl_callback_function(
scope,
callback,
this_arg,
&[value, key, owner.into()],
)?;
Some(())
}
fn new_native_set_iterator<'s>(
scope: &mut v8::PinScope<'s, '_>,
set: v8::Local<'s, v8::Set>,
method: SetlikeWebIdlIteratorMethod,
) -> Option<(v8::Local<'s, v8::Object>, v8::Local<'s, v8::Function>)> {
let intrinsic = native_collection_intrinsic(scope, method.intrinsic_slot())?;
let iterator = intrinsic
.call(scope, set.into(), &[])
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())?;
let next = native_collection_intrinsic(scope, NATIVE_SET_ITERATOR_NEXT_INTRINSIC_SLOT)?;
Some((iterator, next))
}
enum NativeCollectionIteratorStep<'s> {
Value(v8::Local<'s, v8::Value>),
Done,
}
fn advance_native_collection_iterator<'s>(
scope: &mut v8::PinScope<'s, '_>,
iterator: v8::Local<'s, v8::Object>,
next: v8::Local<'s, v8::Function>,
) -> Option<NativeCollectionIteratorStep<'s>> {
let result = next
.call(scope, iterator.into(), &[])
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())?;
if result
.get(scope, v8str(scope, "done").into())
.is_some_and(|value| value.boolean_value(scope))
{
return Some(NativeCollectionIteratorStep::Done);
}
result
.get(scope, v8str(scope, "value").into())
.map(NativeCollectionIteratorStep::Value)
}
fn snapshot_webidl_iterator_prototype<'s>(
scope: &mut v8::PinScope<'s, '_>,
kind: SnapshotWebIdlIteratorKind,
) -> Option<v8::Local<'s, v8::Object>> {
let global = scope.get_current_context().global(scope);
if let Some(existing) = get_private_value(scope, global, kind.prototype_slot())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
{
return Some(existing);
}
let template = kind.build_template(scope);
let prototype = materialize_hidden_function_template_prototype(scope, template)?;
set_private_value(scope, global, kind.prototype_slot(), prototype.into());
Some(prototype)
}
fn setlike_webidl_iterator_prototype<'s>(
scope: &mut v8::PinScope<'s, '_>,
kind: SetlikeWebIdlIteratorKind,
) -> Option<v8::Local<'s, v8::Object>> {
let global = scope.get_current_context().global(scope);
if let Some(existing) = get_private_value(scope, global, kind.prototype_slot())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
{
return Some(existing);
}
let template = kind.build_template(scope);
let prototype = materialize_hidden_function_template_prototype(scope, template)?;
set_private_value(scope, global, kind.prototype_slot(), prototype.into());
Some(prototype)
}
fn snapshot_webidl_iterator_next_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let iterator = args.this();
let Some(values) = get_private_object(scope, iterator, SNAPSHOT_ITERATOR_VALUES_SLOT)
.and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())
else {
throw_type_error(
scope,
"WebIDL iterator next called on an incompatible receiver.",
);
return;
};
let Some(index) = get_private_value(scope, iterator, SNAPSHOT_ITERATOR_INDEX_SLOT)
.and_then(|value| value.integer_value(scope))
.and_then(|value| u32::try_from(value).ok())
else {
throw_type_error(scope, "WebIDL iterator state is unavailable.");
return;
};
if index >= values.length() {
let result =
SnapshotWebIdlIteratorResultDeclaration::new(v8::undefined(scope).into(), true)
.bind(scope)
.expect("WebIDL iterator result declaration should bind");
rv.set(result.into());
return;
}
let value = values
.get_index(scope, index)
.unwrap_or_else(|| v8::undefined(scope).into());
set_private_value(
scope,
iterator,
SNAPSHOT_ITERATOR_INDEX_SLOT,
v8::Integer::new_from_unsigned(scope, index.saturating_add(1)).into(),
);
let result = SnapshotWebIdlIteratorResultDeclaration::new(value, false)
.bind(scope)
.expect("WebIDL iterator result declaration should bind");
rv.set(result.into());
}
fn native_collection_webidl_iterator_next_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(iterator) = get_private_object(scope, args.this(), NATIVE_COLLECTION_ITERATOR_SLOT)
else {
throw_type_error(
scope,
"WebIDL collection iterator next called on an incompatible receiver.",
);
return;
};
let Some(next) = get_private_value(scope, args.this(), NATIVE_COLLECTION_ITERATOR_NEXT_SLOT)
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
else {
throw_type_error(scope, "WebIDL collection iterator state is unavailable.");
return;
};
if let Some(result) = next.call(scope, iterator.into(), &[]) {
rv.set(result);
}
}
fn native_collection_intrinsic<'s>(
scope: &mut v8::PinScope<'s, '_>,
slot: &'static str,
) -> Option<v8::Local<'s, v8::Function>> {
let global = scope.get_current_context().global(scope);
get_private_value(scope, global, slot)
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
}