This is about exposing ALL of the globally available JS APIs through the js-sys crate. Things that are guaranteed by the ECMAScript standard, not Web/Node/etc APIs.

A good overview/list/documentation of these APIs is available here and I've also made a checklist below. As we implement bindings for these APIs, I will check them off.

How to Implement New Bindings

• Comment here saying which thing you are going to make bindings for (so that we don't accidentally duplicate effort). I'll add your username next to the checkbox item.

• Open the MDN page for the relevant JS API.

• Open crates/js-sys/src/lib.rs in your editor; this is the file where we are implementing the bindings.

• Follow the instructions in crates/js-sys/src/lib.rs about how to add new bindings: https://github.com/rustwasm/wasm-bindgen/blob/aa348f963ff4ae7ddd769365ad1b197cd134e24e/crates/js-sys/src/lib.rs#L28-L44

• Add a test for the new binding to crates/js-sys/tests/wasm/MyType.rs

• Run the JS global API bindings tests with cargo test -p js-sys --target wasm32-unknown-unknown

• Send a pull request! :smile_cat:

Depends on this PR for the initial skeleton and infrastructure:

• [X] https://github.com/rustwasm/wasm-bindgen/pull/274

All String bindings depend on:

• [x] https://github.com/rustwasm/wasm-bindgen/issues/287

• [x] Array

  • [x] Array.length (@robertDurst)

  • [x] Array.from()

  • [x] Array.isArray()

  • [x] Array.of()

  • [x] Array.prototype.concat()

  • [x] Array.prototype.copyWithin()

  • [x] Array.prototype.entries()

  • [x] Array.prototype.every()

  • [x] Array.prototype.fill()

  • [x] Array.prototype.filter()

  • [x] Array.prototype.find()

  • [x] Array.prototype.findIndex()

  • [x] Array.prototype.forEach()

  • [x] Array.prototype.includes()

  • [x] Array.prototype.indexOf()

  • [x] Array.prototype.join()

  • [x] Array.prototype.keys()

  • [x] Array.prototype.lastIndexOf()

  • [x] Array.prototype.map()

  • [x] Array.prototype.pop() (@sepiropht)

  • [x] Array.prototype.push()

  • [x] Array.prototype.reduce()

  • [x] Array.prototype.reduceRight()

  • [x] Array.prototype.reverse()

  • [x] Array.prototype.shift()

  • [x] Array.prototype.slice()

  • [x] Array.prototype.some()

  • [x] Array.prototype.sort()

  • [x] Array.prototype.splice()

  • [x] Array.prototype.toLocaleString()

  • [x] Array.prototype.toString()

  • [x] Array.prototype.unshift()

  • [x] Array.prototype.values()

• [x] ArrayBuffer

  • [x] ArrayBuffer.prototype.byteLength

  • [x] ArrayBuffer.isView()

  • [x] ArrayBuffer.prototype.slice()

• [x] Boolean

• [x] DataView

  • [x] DataView.prototype.buffer

  • [x] DataView.prototype.byteLength

  • [x] DataView.prototype.byteOffset

  • [x] DataView.prototype.getFloat32()

  • [x] DataView.prototype.getFloat64()

  • [x] DataView.prototype.getInt16()

  • [x] DataView.prototype.getInt32()

  • [x] DataView.prototype.getInt8()

  • [x] DataView.prototype.getUint16()

  • [x] DataView.prototype.getUint32()

  • [x] DataView.prototype.getUint8()

  • [x] DataView.prototype.setFloat32()

  • [x] DataView.prototype.setFloat64()

  • [x] DataView.prototype.setInt16()

  • [x] DataView.prototype.setInt32()

  • [x] DataView.prototype.setInt8()

  • [x] DataView.prototype.setUint16()

  • [x] DataView.prototype.setUint32()

  • [x] DataView.prototype.setUint8()

• [x] Date

  • [x] Date.UTC()

  • [x] Date.now()

  • [x] Date.parse()

  • [x] Date.prototype.getDate()

  • [x] Date.prototype.getDay()

  • [x] Date.prototype.getFullYear()

  • [x] Date.prototype.getHours()

  • [x] Date.prototype.getMilliseconds()

  • [x] Date.prototype.getMinutes()

  • [x] Date.prototype.getMonth()

  • [x] Date.prototype.getSeconds()

  • [x] Date.prototype.getTime()

  • [x] Date.prototype.getTimezoneOffset()

  • [x] Date.prototype.getUTCDate()

  • [x] Date.prototype.getUTCDay()

  • [x] Date.prototype.getUTCFullYear()

  • [x] Date.prototype.getUTCHours()

  • [x] Date.prototype.getUTCMilliseconds()

  • [x] Date.prototype.getUTCMinutes()

  • [x] Date.prototype.getUTCMonth()

  • [x] Date.prototype.getUTCSeconds()

  • [x] Date.prototype.setDate()

  • [x] Date.prototype.setFullYear()

  • [x] Date.prototype.setHours()

  • [x] Date.prototype.setMilliseconds()

  • [x] Date.prototype.setMinutes()

  • [x] Date.prototype.setMonth()

  • [x] Date.prototype.setSeconds()

  • [x] Date.prototype.setTime()

  • [x] Date.prototype.setUTCDate()

  • [x] Date.prototype.setUTCFullYear()

  • [x] Date.prototype.setUTCHours()

  • [x] Date.prototype.setUTCMilliseconds()

  • [x] Date.prototype.setUTCMinutes()

  • [x] Date.prototype.setUTCMonth()

  • [x] Date.prototype.setUTCSeconds()

  • [x] Date.prototype.toDateString()

  • [x] Date.prototype.toISOString()

  • [x] Date.prototype.toJSON()

  • [x] Date.prototype.toLocaleDateString()

  • [x] Date.prototype.toLocaleString()

  • [x] Date.prototype.toLocaleTimeString()

  • [x] Date.prototype.toString()

  • [x] Date.prototype.toTimeString()

  • [x] Date.prototype.toUTCString()

  • [x] Date.prototype.valueOf()

• [x] Error

  • [x] Error.prototype.message

  • [x] Error.prototype.name

  • [x] Error.prototype.toString()

• [x] EvalError

• [x] Float32Array

• [x] Float64Array

• [x] Function

  • [x] Function.length

  • [x] Function.name

  • [x] Function.prototype.apply()

  • [x] Function.prototype.bind()

  • [x] Function.prototype.call()

  • [x] Function.prototype.toString()

• [x] Generator

  • [x] Generator.prototype.next()

  • [x] Generator.prototype.return()

  • [x] Generator.prototype.throw()

• [x] Int16Array

• [x] Int32Array

• [x] Int8Array

• [x] Intl

  • [x] Intl.getCanonicalLocales()

• [x] Intl.Collator

  • [x] Intl.Collator.prototype.compare

  • [x] Intl.Collator.prototype.resolvedOptions()

  • [x] Intl.Collator.supportedLocalesOf()

• [x] Intl.DateTimeFormat

  • [x] Intl.DateTimeFormat.prototype.format

  • [x] Intl.DateTimeFormat.prototype.formatToParts()

  • [x] Intl.DateTimeFormat.prototype.resolvedOptions()

  • [x] Intl.DateTimeFormat.supportedLocalesOf()

• [x] Intl.NumberFormat

  • [x] Intl.NumberFormat.prototype.format

  • [x] Intl.NumberFormat.prototype.formatToParts()

  • [x] Intl.NumberFormat.prototype.resolvedOptions()

  • [x] Intl.NumberFormat.supportedLocalesOf()

• [x] Intl.PluralRules

  • [x] Intl.PluralRules.prototype.resolvedOptions()

  • [x] Intl.PluralRules.select()

  • [x] Intl.PluralRules.supportedLocalesOf()

• [x] JSON

  • [x] JSON.parse()

  • [x] JSON.stringify()

• [x] Map

  • [x] Map.prototype.size

  • [x] Map.prototype.clear()

  • [x] Map.prototype.delete()

  • [x] Map.prototype.entries()

  • [x] Map.prototype.forEach()

  • [x] Map.prototype.get()

  • [x] Map.prototype.has()

  • [x] Map.prototype.keys()

  • [x] Map.prototype.set()

  • [x] Map.prototype.values()

• [x] Math

  • [x] Math.abs()

  • [x] Math.acos()

  • [x] Math.acosh()

  • [x] Math.asin()

  • [x] Math.asinh()

  • [x] Math.atan()

  • [x] Math.atan2()

  • [x] Math.atanh()

  • [x] Math.cbrt()

  • [x] Math.ceil()

  • [x] Math.clz32()

  • [x] Math.cos()

  • [x] Math.cosh()

  • [x] Math.exp()

  • [x] Math.expm1()

  • [x] Math.floor()

  • [x] Math.fround()

  • [x] Math.hypot()

  • [x] Math.imul()

  • [x] Math.log()

  • [x] Math.log10()

  • [x] Math.log1p()

  • [x] Math.log2()

  • [x] Math.max()

  • [x] Math.min()

  • [x] Math.pow()

  • [x] Math.random()

  • [x] Math.round()

  • [x] Math.sign()

  • [x] Math.sin()

  • [x] Math.sinh()

  • [x] Math.sqrt()

  • [x] Math.tan()

  • [x] Math.tanh()

  • [x] Math.trunc()

• [x] Number

  • [x] Number.isFinite()

  • [x] Number.isInteger()

  • [x] Number.isNaN()

  • [x] Number.isSafeInteger()

  • [x] Number.parseFloat()

  • [x] Number.parseInt()

  • [x] Number.prototype.toExponential()

  • [x] Number.prototype.toFixed()

  • [x] Number.prototype.toLocaleString()

  • [x] Number.prototype.toPrecision()

  • [x] Number.prototype.toString()

  • [x] Number.prototype.valueOf()

• [x] Object

  • [x] Object.prototype.constructor

  • [x] Object.assign()

  • [x] Object.create()

  • [x] Object.defineProperties()

  • [x] Object.defineProperty()

  • [x] Object.entries()

  • [x] Object.freeze()

  • [x] Object.getOwnPropertyDescriptor()

  • [x] Object.getOwnPropertyDescriptors()

  • [x] Object.getOwnPropertyNames()

  • [x] Object.getOwnPropertySymbols()

  • [x] Object.getPrototypeOf()

  • [x] Object.is()

  • [x] Object.isExtensible()

  • [x] Object.isFrozen()

  • [x] Object.isSealed()

  • [x] Object.keys()

  • [x] Object.preventExtensions()

  • [X] Object.prototype.hasOwnProperty()

  • [X] Object.prototype.isPrototypeOf() (@belfz)

  • [x] Object.prototype.propertyIsEnumerable() (@belfz )

  • [x] Object.prototype.toLocaleString()

  • [X] Object.prototype.toString() (@jonathan-s)

  • [x] Object.prototype.valueOf()

  • [x] Object.seal()

  • [x] Object.setPrototypeOf()

  • [x] Object.values()

• [x] Promise

  • [x] Promise.all()

  • [x] Promise.prototype.catch()

  • [x] Promise.prototype.finally()

  • [x] Promise.prototype.then()

  • [x] Promise.race()

  • [x] Promise.reject()

  • [x] Promise.resolve()

• [x] Proxy

• [x] RangeError

• [x] ReferenceError

• [x] Reflect

  • [x] Reflect.apply()

  • [x] Reflect.construct()

  • [x] Reflect.defineProperty()

  • [x] Reflect.deleteProperty()

  • [x] Reflect.get()

  • [x] Reflect.getOwnPropertyDescriptor()

  • [x] Reflect.getPrototypeOf()

  • [x] Reflect.has()

  • [x] Reflect.isExtensible()

  • [x] Reflect.ownKeys()

  • [x] Reflect.preventExtensions()

  • [x] Reflect.set()

  • [x] Reflect.setPrototypeOf()

• [x] RegExp

  • [x] RegExp.$1-$9

  • [x] RegExp.input ($_)

  • [x] RegExp.lastMatch ($&)

  • [x] RegExp.lastParen ($+)

  • [x] RegExp.leftContext ($)`

  • [x] RegExp.prototype.flags

  • [x] RegExp.prototype.global

  • [x] RegExp.prototype.ignoreCase

  • [x] RegExp.prototype.multiline

  • [x] RegExp.prototype.source

  • [x] RegExp.prototype.sticky

  • [x] RegExp.prototype.unicode

  • [x] RegExp.rightContext ($')

  • [x] regexp.lastIndex

  • [x] RegExp.prototype.exec()

  • [x] RegExp.prototype.test()

  • [x] RegExp.prototype.toString()

• [x] Set

  • [x] Set.prototype.size

  • [x] Set.prototype.add()

  • [x] Set.prototype.clear()

  • [x] Set.prototype.delete()

  • [x] Set.prototype.entries()

  • [x] Set.prototype.forEach()

  • [x] Set.prototype.has()

  • [x] Set.prototype.values()

• [x] String

  • [x] string.length

  • [x] String.fromCharCode()

  • [x] String.fromCodePoint()

  • [x] String.prototype.charAt()

  • [x] String.prototype.charCodeAt()

  • [x] String.prototype.codePointAt()

  • [x] String.prototype.concat()

  • [x] String.prototype.endsWith()

  • [x] String.prototype.includes()

  • [x] String.prototype.indexOf()

  • [x] String.prototype.lastIndexOf()

  • [x] String.prototype.localeCompare()

  • [x] String.prototype.match()

  • [x] String.prototype.normalize()

  • [x] String.prototype.padEnd()

  • [x] String.prototype.padStart()

  • [x] String.prototype.repeat()

  • [x] String.prototype.replace()

  • [x] String.prototype.search()

  • [x] String.prototype.slice()

  • [x] String.prototype.split()

  • [x] String.prototype.startsWith()

  • [x] String.prototype.substr()

  • [x] String.prototype.substring()

  • [x] String.prototype.toLocaleLowerCase()

  • [x] String.prototype.toLocaleUpperCase()

  • [x] String.prototype.toLowerCase()

  • [x] String.prototype.toString()

  • [x] String.prototype.toUpperCase()

  • [x] String.prototype.trim()

  • [x] String.prototype.trimEnd()

  • [x] String.prototype.trimStart()

  • [x] String.prototype.valueOf()

  • [x] String.raw()

• [x] Symbol

  • [x] Symbol.hasInstance

  • [x] Symbol.isConcatSpreadable

  • [x] Symbol.iterator

  • [x] Symbol.match

  • [x] Symbol.replace

  • [x] Symbol.search

  • [x] Symbol.species

  • [x] Symbol.split

  • [x] Symbol.toPrimitive

  • [x] Symbol.toStringTag

  • [x] Symbol.unscopables

  • [x] Symbol.for()

  • [x] Symbol.keyFor()

  • [x] Symbol.prototype.toString()

  • [x] Symbol.prototype.valueOf()

• [x] SyntaxError

• [x] TypeError

• [x] URIError

• [x] Uint16Array

• [x] Uint32Array

• [x] Uint8Array

• [x] Uint8ClampedArray

• [x] WeakMap

  • [x] WeakMap.prototype.delete()

  • [x] WeakMap.prototype.get()

  • [x] WeakMap.prototype.has()

  • [x] WeakMap.prototype.set()

• [x] WeakSet

  • [x] WeakSet.prototype.add()

  • [x] WeakSet.prototype.delete()

  • [x] WeakSet.prototype.has()

• [x] WebAssembly

  • [x] WebAssembly.compile()

  • [x] WebAssembly.instantiate()

  • [x] WebAssembly.instantiateStreaming()

  • [x] WebAssembly.validate()

• [x] WebAssembly.Module

  • [x] WebAssembly.Module.customSections()

  • [x] WebAssembly.Module.exports()

  • [x] WebAssembly.Module.imports()

• [x] WebAssembly.Instance

  • [x] WebAssembly.Instance.prototype.exports

• [x] WebAssembly.Memory

  • [x] WebAssembly.Memory.prototype.buffer

  • [x] WebAssembly.Memory.prototype.grow

• [x] WebAssembly.Table

  • [x] WebAssembly.Table.prototype.length

  • [x] WebAssembly.Table.prototype.get

  • [x] WebAssembly.Table.prototype.grow

  • [x] WebAssembly.Table.prototype.set

• [x] WebAssembly.CompileError

• [x] WebAssembly.LinkError

• [x] WebAssembly.RuntimeError

• [X] decodeURI()

• [x] decodeURIComponent()

• [X] encodeURI()

• [x] encodeURIComponent()

• [x] escape()

• [X] eval()

• [x] isFinite()

• [x] isNaN()

• [x] null

• [x] parseFloat()

• [x] parseInt()

• [x] undefined

• [x] unescape()

the wasm-bindgen-futures crate provides for consuming promises as futures, and returning futures to JS as promises, but not executing futures in wasm.

I'm currently experimenting with borrowing the strategy for passing futures to js for my use-case.

Motivation

When used without a bundler, there is a need to call init with a .wasm file name:

await init('../pkg/my_project_bg.wasm');

and again

await init('../pkg/another_project_bg.wasm');

Proposed Solution

Make it possible to use

await init();

which will default to path with generated .wasm file

This allows types to define custom Rust code as an override for JsCast::instanceof.

• Fixes #1367 for types that have built-in cross-realm checks, allowing dyn_ref and dyn_into to accept values from other realms. In particular:
  • .instanceof::<Array>() will now automatically use Array::is_array instead of actual ... instanceof Array.
  • .instanceof::<Function>() will use JsValue::is_function. This also simplifies Function::try_from to being an alias for dyn_ref::<Function>().
  • .dyn_into::<JsString>(), .dyn_into::<Number>(), .dyn_into::<Boolean>() will also now use corresponding checks from JsValue. In theory, these 3 can break checks if someone has been using boxed primitives (new String(...), new Number(...), new Boolean(...)), but these are extremely rare in real-world JS code and are already not support by JsValue methods. If we do want to support them, I believe it should be done at the JsValue level in as_f64, as_bool, as_string too.
• Fixes #1370 - .instanceof::<Symbol>() will now use JsValue::is_symbol - previously it would return false for any value, even actual Symbols, making it impossible to use .dyn_ref::<Symbol>() and .dyn_into::<Symbol>().

cc @alexcrichton @fitzgen

Describe the Bug

It was brought to my attention in https://github.com/Pauan/rust-dominator/issues/10 that JavaScript strings (and DOMString) allow for unpaired surrogates.

When using TextEncoder, it will convert those unpaired surrogates into U+FFFD (the replacement character). According to the Unicode spec, this is correct behavior.

The issue is that because the unpaired surrogates are replaced, this is lossy, and that lossiness can cause serious issues.

You can read the above dominator bug report for the nitty gritty details, but the summary is that with <input> fields (and probably other things), it will send two input events, one for each surrogate.

When the first event arrives, the surrogate is unpaired, so because the string is immediately sent to Rust, the unpaired surrogate is converted into the replacement character.

Then the second event arrives, and the surrogate is still unpaired (because the first half was replaced), so the second half also gets replaced with the replacement character.

This has a lot of very deep implications, including for international languages (e.g. Chinese).

I did quite a bit of reading, and unfortunately I think the only real solution here is to always use JsString, and not convert into Rust String, because that is inherently lossy. Or if a conversion is done, it needs to do some checks to make sure that there aren't any unpaired surrogates.

#[no_mangle]
#[wasm_bindgen]
pub extern fn optional() -> Option<i32> {
    None
}

Ideally this would be returned as null on the JS side

the trait `wasm_bindgen::convert::WasmBoundary` is not implemented for `std::option::Option<i32>`

(this seems like lower hanging fruit than Result)

The good news is that I'm getting my head around WebAssembly so I may be able to help in the future 🤞

Edit: Oof, maybe it's best to tackle the general generics problem before specializing for the Option use case.

As discussed in today's WG meeting, we are aiming for publishing an initial release of the web-sys crate for the Rust 2018 Release Candidate milestone. That's 6 weeks from now: 2018-09-13.

What needs to be done before we ship an initial release of web-sys?

Goals

• [x] Namespaces support: https://github.com/rustwasm/wasm-bindgen/issues/253
• [x] Remove all typedefs: https://github.com/rustwasm/wasm-bindgen/issues/623
• [x] Headless testing in Chrome: https://github.com/rustwasm/wasm-bindgen/issues/622
• [x] Support HTMLConstructor attribute: https://github.com/rustwasm/wasm-bindgen/issues/621
• [x] Enable bindings generation for all the interfaces that need Option<scalar>: https://github.com/rustwasm/wasm-bindgen/issues/624
• [x] Enable bindings generation for all the interfaces that use funky-named enum variants: https://github.com/rustwasm/wasm-bindgen/issues/625
• [x] Implement inheritance and upcasting from RFC #2
• [x] Support WebIDL getters/setters: #248
• [x] Generate bindings for document.createElement: https://github.com/rustwasm/wasm-bindgen/issues/658
• [x] Expose a getter for the global window: https://github.com/rustwasm/wasm-bindgen/issues/659
• [x] Support WebIDL dictionaries: https://github.com/rustwasm/wasm-bindgen/issues/241
• [x] Support WebIDL callbacks: https://github.com/rustwasm/wasm-bindgen/issues/257
• [x] Feature gate individual interfaces to get faster compile times: https://github.com/rustwasm/wasm-bindgen/pull/790
• [x] Do a final audit of unsupported warnings and determine if any of them are blocking critical web APIs (eg the body for fetch thing in #817)
• [x] Do an audit for moz-prefixed APIs that shouldn't be included in web-sys
• [x] Figure out how to expose global window APIs: https://github.com/rustwasm/wasm-bindgen/issues/834
• [x] Have announcement blog post ready to publish at the same time that we push to crates.io

Stretch

• [ ] RFC and implementation for traits to expose a derived type's inherited methods
• [ ] Add an example of working with the DOM via web-sys: https://github.com/rustwasm/wasm-bindgen/issues/446

What else should we make sure is done for an initial release? For reference, here are all the "frontend:webidl" issues andhere are all the "web-sys" issues

+cc @ohanar @alexcrichton @twilco @dodj @jonathanKingston

The #[wasm_bindgen] attribute is pretty feature-ful right now and notably allows importing a class from JS and using it in Rust. Unfortunately though it's a pretty manual process to write this out for web apis, so it'd be great to do this automatically!

Thankfully there's this awesome thing called WebIDL which is a programmatic description of APIs available on the web. There's even two parsers on crates.io for WebIDL!

I think it'd be pretty neat if a WebIDL generator were added to this repo to automatically generate #[wasm_bindgen] decorated bindings. In that sense I'd imagine that we could auto-generate a bunch of *-sys crates which provide bindings for all the web-related functionality JS has to offer. At that point working with the DOM or other web APIs should be as simple as extern crate foo!

An issue like this certainly has a lot of design questions to explore as I'm sure WebIDL is far richer than what #[wasm_bindgen] supports today. We'll need to add features to #[wasm_bindgen] along the way as well as probably developing idioms to map JS to Rust, but I think it'd be great to at least start out with some simple APIs to see how it goes.

For example the README has an example:

#[wasm_bindgen]
extern {
    fn alert(s: &str);
}

but it'd be awesome if we could automatically generate this binding from a WebIDL file and place it in a crate to use. Once we have the "hello world" variants working we should hopefully have enough information to inform the next phase of design questions.

I mentioned here https://github.com/WebAssembly/design/issues/1172 that we will be able to use the BigInt proposal to represent the i64 values from WebAssembly.

Currently there is not support for BigInt in browsers (nor in Babel). So I believe we can use this kind of tools to allow it.

We use a 64 bit two's-complement (https://github.com/dcodeIO/long.js).

Have you considered to implement it?

Edit: I just remembered that WebAssembly doesn't allow multiple results for a func, I'm not sure what's the best solution, maybe the linear memory?

When I said "we use" I meant in https://github.com/xtuc/webassemblyjs which is not the same use-case.

This is a pretty big change which touches on a bunch of things, but it shouldn't be a breaking change.

The reason for this PR is that web-sys takes an absurdly long time to build:

1:18 minutes web-sys build.rs
2:01 minutes web-sys compile
4:17 minutes total

As you can see, web-sys alone is taking up 3:19 minutes out of the 4:17 minutes build time. A big chunk of that is running the build.rs script, but even the compilation afterwards takes way too long.

This is in a project which is about as close to "hello world" as it gets:

[dependencies.web-sys]
version = "0.3.35"
features = [
    "console",
    "Window",
]

So it really should not be taking that long. And even worse, it has to do a full recompilation every time you add a new feature to the features list, which happens often during development.

This PR completely fixes that, so now it looks like this:

0:07 minutes web-sys compile
1:03 minutes total

The build.rs script is completely gone, and now it takes a mere 7 seconds to compile web-sys, which means the project now only takes 1:03 minutes to build rather than 4:17 minutes.

This PR accomplishes that by doing the following:

1. Rather than using a build.rs script to re-parse and re-generate from WebIDL every single time, instead it uses a bin/build-web-sys script to generate the WebIDL once. This script only needs to be re-run when changing the WebIDL.

2. This new script creates a separate file for each feature, so the "Window" feature corresponds to the web-sys/src/bindings/gen_Window.rs file.

3. It creates a web-sys/src/bindings/mod.rs file which re-exports all of the gen_ files, and it uses cfg so each file will be behind a feature flag. That means Rust doesn't even need to parse the files which aren't enabled, so everything is much faster.

4. It adds new cfg flags inside of the gen_ files to accommodate things like Window::navigator which should only be enabled if Navigator is enabled.

   This also means it needed to add some cfg flags to the descriptor glue code generated by #[wasm_bindgen]. I don't particularly like this, but I don't see a better way.

5. In Cargo.toml it generates the [features] list with appropriate dependencies already specified (so "Window" depends on "EventTarget", etc.)

This is a bit of a rough PR, so there might be some mistakes or a better way to accomplish this, but I think it's a solid start.

This has the following benefits:

1. Obviously this is far faster, saving 3:12 minutes on build time for web-sys.

2. The wasm-bindgen-webidl crate is no longer a dependency of web-sys, further improving the build times.

3. It's no longer necessary to do hacky things like setting the __WASM_BINDGEN_DUMP_FEATURES env var.

4. Because the generated files are checked into git, that means we get git diffs when changing the WebIDL.

5. The generated code is properly formatted, so rustdocs will actually be usable now.

6. I think this moves us a little bit closer to allowing users to generate their own crates based on WebIDL.

To actually run the script, just cd bin/build-web-sys and then do cargo run --release. All of the code will be auto-generated in the right folders. The features list will be in the web-sys/features file, which can then be copied over to the web-sys/Cargo.toml file.

The Websys section of the official guide includes how to build WASM modules, but not how you'd use in a webpage. For example, if I create an HTML file, serve it, and add <script type="module" src="my_module.js"></script>, I receive the error in browser console: Loading failed for the module with source “http://localhost:8000/my_module_bg”.

I've found I can get it working using Webpack 4, with a minimal package.json, webpack.config.js, and but is there a way to do this without using the Webpack and npm ecosystem, eg pure Rust?

index.html includes: <script type="module" src="main.js"></script>

package.json:

{
  "name": "my_module",
  "license": "MIT",
  "version": "0.1.0",
  "dependencies": {},
  "scripts": {
    "serve": "webpack-dev-server"
  },
  "devDependencies": {
    "webpack": "^4.15.1",
    "webpack-cli": "^3.0.8",
    "webpack-dev-server": "^3.1.4"
  }
}

webpack.config.js:

const path = require('path');

module.exports = {
    entry: path.join(__dirname, 'main.ts'),
    output: {
        filename: 'main.js',
        path: __dirname
    },
    module: {
        rules: [
            {
                exclude: /node_modules/,
            },
        ],

    },
    resolve: {
        extensions: [".tsx", ".ts", ".js", ".wasm"]
    },
    mode: "development"
};

main.ts:

const rust = import("./my_module");

rust.then(r => r.run())

Stated another way: How can I replace the above code with this line in index.html? <script type="module" src="my_module.js"></script> (or .wasm, or _bg.wasm )

Describe the Bug

Importing a function that returns an i64 currently results in a Cannot convert to BigInt error

Steps to Reproduce

1. Set up the following files:

# ./cargo.toml
[package]
name = "wasm-bindgen-bigint"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2.83"

// ./src/index.js
const big_num = 6255361224;

exports.get_big_num = () => {
    return big_num;
}

// ./src/lib.rs
use wasm_bindgen::prelude::*;

#[wasm_bindgen(module = "/src/index.js")]
extern "C" {
    #[wasm_bindgen]
    pub fn get_big_num() -> i64;
}

#[wasm_bindgen]
pub fn check_bigint() {
    let big_num = get_big_num();
    panic!("{}", big_num);
}

// ./index.js

let pkg = import("./pkg/wasm_bindgen_bigint.js");

pkg.then((m) => {
    m.check_bigint();
})

2. run cargo build --target wasm32-unknown-unknown --release
3. and then: wasm-bindgen --target nodejs --out-dir ./pkg ./target/wasm32-unknown-unknown/release/wasm_bindgen_bigint.wasm
4. run node index.ts

Expected Behavior

Expect a panic with just the number 6255361224 as output.

Actual Behavior

Error returned: TypeError: Cannot convert 6255361224 to a BigInt

Additional Context

node version: v19.3.0

This happens with any imported function if you set the return type to i64 even small numbers like 5.

JsCast is a very commonly used trait, but for some reason has never been added to wasm_bindgen::prelude, leading to the constant annoyance of having to manually import it.

Motivation

There is a number of conversions implemented from Rust primitive types, but () is missing.

Proposed Solution

I'm not familiar with project internals, my first guess it to have straightforward From implementation to go from () to JsValue::undefined().

Alternatives

Do it manually on call site, but I'd like to see T: Into<JsValue> to catch this case also, as T may come simply from something like Result<(), Error> which is not that uncommon.

Describe the Bug

error from HTML pipeline

Caused by: 0: error from asset pipeline 1: failed downloading release archive 2: error sending HTTP request 3: error sending request for url (https://github.com/rustwasm/wasm-bindgen/releases/download/0.2.83/wasm-bindgen-0.2.83-x86_64-unknown-linux-musl.tar.gz): error trying to connect: tcp connect error: Connection timed out (os error 110) 4: error trying to connect: tcp connect error: Connection timed out (os error 110) 5: tcp connect error: Connection timed out (os error 110) 6: Connection timed out (os error 110)

Fixes #2560

It's possible for some members of an interface (or namespace) to be stable and others not, if a partial interface is defined in an unstable webidl file which adds to an interface defined in a stable file. This wasn't properly kept track of for all interface members before, most notably for operations. This PR fixes that.

This did unfortunately root out some WebXR-related bits of WebGL that were marked stable when they shouldn't have been. So, currently, this is a slight breaking change. I'm not sure if I should special-case them to be left as stable or accept the slight risk of breakage, since it seems unlikely that people would be using these isolated bits of WebXR without enabling --cfg=web_sys_unstable_apis for the rest of WebXR.