Bindings with requires about gen_js_api

[jchavarri]

I picked up the branch in #68 and updated it with latest master to explore the generated code for require attributes. One challenge is that in development mode, gen_js_api (in particular, these changes in ojs.ml) produces the following output after running through jsoo:

var internal_require=require;
function require$0(name){return internal_require(name.toString())}

This is a no-go for most common JavaScript bundlers like Webpack, that need the string passed to require to be a literal so it can be resolved at bundling time.

If I compile using the --profile=prod flag in Dune, then all these map functions like .toString get inlined so the expressions are resolved with literals, but I wonder if there's a way to "move forward" this expression generation so the resulting code can contain the string literal already?

Aside: I can create a PR with the updated branch if it helps.

[alainfrisch]

First, even with the manual encoding, you could use gen_js_api to produce a binding for:

  type a_module = Ojs.t
  val foo_internal: a_module -> string -> int

and then simply define the user-visible foo in term of this foo_internal:

  let a = lazy (...)
  let foo x = foo_internal (Lazy.force a) x

Now, assuming that a Javascript global variable A_module is bound to the result of require("A") (either with manual JS code, or through gen_js_api), you can also directly expose:

  val foo: string -> int [@@js.global "A_module.foo"]

One could also design some built-in gen_js_api support for this scheme, perhaps bound to OCaml modules:

module A : sig
  val foo: string -> int
end [@@js.require]

within a module marked with the js.require attribute, all functions would implicitly be assumed to be on the object resulting from a call to require (by default, with a name derived from the module binding, with a way to override that).

[Aaylor]

Thanks for your answer !
I wrote the ml file instead of the mli using an internal representation, allowing me to hide the internal module with the mli file:

module A_internal : sig
  type a_internal = Ojs.t
  val foo : a_internal ->int -> int
end

let mod_a = lazy (Helpers.require "a")
let foo i = A_internal.foo mod_a i

Implementing such an attribute could be a great idea to avoid code duplication or errors. Would you see this in gen_js_api ? I could give a try to add this attribute.

[alainfrisch]

Would you see this in gen_js_api ? I could give a try to add this attribute.

Yes, absolutely! If some "small" additions to the tool simplify supporting common idioms in bindings, they are very much welcome.

[Lupus]

Writing quite some Node bindings - and it's annoying to bind modules to some globals and then reference those in @js.global. It's still not bundler friendly, but I have to do it manually...

[mlasson]

Closing due to inactivity.