cargo web
0.6.26
Cette sous-commande de fret vise à faciliter la création, à développer et à déployer des applications Web côté client écrit en rouille.
Ce logiciel vous a été apporté grâce à ces gens merveilleux:
Merci!
Actuellement, il prend en charge les fonctionnalités suivantes:
cargo web build - construire votre projet en utilisant l'un des trois backends Web de Rust:--target=wasm32-unknown-unknown ; par défaut)--target=wasm32-unknown-emscripten )--target=asmjs-unknown-emscripten )cargo web check - TypeCheck votre projetcargo web test - exécutera vos tests sous:--nodejs )cargo web start - construire votre projet, démarrer un serveur Web intégré et le reconstruire en permanence si nécessaire; Prend en charge le rechargement automatique avec --auto-reload .cargo web deploy - construire votre projet et émettra tous les fichiers nécessaires afin que vous puissiez facilement les servir statiquement.rustup Il est également fortement recommandé de consulter la caisse Stdweb si vous souhaitez interagir avec le monde JavaScript de votre projet. (En fait, cargo-web est ce qui permet d'utiliser js! Macro de stdweb sur le backend WebAssembly natif de Rust.)
$ cargo install cargo-web
Pour mettre à niveau:
$ cargo install --force cargo-web
Ou cloner et construire avec $ cargo build --release puis placez dans votre piste $.
Sur Linux, l'installation peut échouer avec un message qu'il ne peut pas trouver OpenSSL, auquel cas vous devez très probablement installer le package -dev pour OpenSSL à partir des référentiels de votre distribution. (Sur Ubuntu, cela s'appelle libssl-dev .)
Web.toml cargo-web a son propre fichier de configuration que vous pouvez mettre à côté de cargo 's Cargo.toml .
Voici un exemple de configuration montrant chaque clé prise en charge:
# The default value of `--target` used when building this crate
# in cases where it's not specified on the command line.
default-target = " wasm32-unknown-unknown "
# This will prepend a given JavaScript file to the resulting `.js` artifact.
# You can put any initialization code here which you'd like to have executed
# when your `.js` file first loads.
#
# This accepts either a string (as shown here), or an array of strings,
# in which case it will prepend all of the specified files in their
# order of appearance.
prepend-js = " src/runtime.js "
[ cargo-web ]
# Asserts the minimum required version of `cargo-web` necessary
# to compile this crate; supported since 0.6.0.
minimum-version = " 0.6.0 "
# These will only take effect on *-emscripten targets.
[ target . emscripten ]
# You can have a target-specific `prepend-js` key.
prepend-js = " src/emscripten_runtime.js "
# This will enable Emscripten's SDL2 port. Consult Emscripten's documentation
# for more details.
link-args = [ " -s " , " USE_SDL=2 " ]
# You can also specify the target by its full name.
[ target . wasm32-unknown-unknown ]
prepend-js = " src/native_runtime.js " Si vous utilisez des caisses externes qui ont un Web.toml , cargo-web le chargera et l'utilisera.
Quelques restrictions concernant le Web.toml :
prepend-js qui se chevauchent. Vous pouvez soit définir un seul prepend-js Global, soit plusieurs paroles par cible.link-args ne peuvent actuellement pas avoir d'espaces.cargo-web traitera les fichiers Web.toml à partir de plusieurs caisses est déterministe mais non spécifiée. Cela signifie que vous ne devriez en aucun cas dépendre de cette commande. Tous les fichiers statiques que vous souhaitez avoir servi lors de l' cargo web start ou déployé lors de l'exécution cargo web deploy peuvent être placés dans un répertoire appelé static à la racine de votre caisse. Aucun artefact statique n'est requis par défaut; Un fichier index.html sera automatiquement généré pour vous s'il manque. Vous pouvez, bien sûr, mettre votre propre fichier static/index.html , auquel cas il sera utilisé à la place de celui autogénéré.
cargo-web pendant la compilation Si pendant la compilation, vous souhaitez détecter que votre projet est en cours de construction avec cargo-web vous pouvez vérifier la variable d'environnement COMPILING_UNDER_CARGO_WEB , qui sera définie sur 1 .
cargo-web sur Travis Vous pouvez utiliser le script suivant pour télécharger et installer le dernier cargo-web :
CARGO_WEB_RELEASE= $( curl -L -s -H ' Accept: application/json ' https://github.com/koute/cargo-web/releases/latest )
CARGO_WEB_VERSION= $( echo $CARGO_WEB_RELEASE | sed -e ' s/.*"tag_name":"([^"]*)".*/1/ ' )
if [ " $( uname -s ) " == " Darwin " ] ; then
CARGO_WEB_HOST_TRIPLE= " x86_64-apple-darwin "
else
CARGO_WEB_HOST_TRIPLE= " x86_64-unknown-linux-gnu "
fi
CARGO_WEB_URL= " https://github.com/koute/cargo-web/releases/download/ $CARGO_WEB_VERSION /cargo-web- $CARGO_WEB_HOST_TRIPLE .gz "
echo " Downloading cargo-web from: $CARGO_WEB_URL "
curl -L $CARGO_WEB_URL | gzip -d > cargo-web
chmod +x cargo-web
mkdir -p ~ /.cargo/bin
mv cargo-web ~ /.cargo/bin Par défaut, cargo web test exécutera vos tests sous Chrome sans tête. Pour pouvoir l'utiliser sur Travis, vous devez ajouter quelque chose comme ça à votre .travis.yml :
addons :
chrome : stable wasm32-unknown-unknown -Nly) Lors de la création d'un projet par défaut cargo-web génère un exécution autonome pour vous. Cela signifie que le fichier .js généré peut être immédiatement mis à l'intérieur d'une balise <script> ou lancé avec node.js sans avoir à le charger manuellement ou faire quoi que ce soit de plus, mais cela vous limite en ce qui concerne la personnalisation.
Si vous souhaitez avoir un peu plus de contrôle sur la façon dont votre module est chargé, vous pouvez dire à cargo-web pour générer un module non standalone de type bibliothèque pour vous avec l'option --runtime library-es6 . Cela se traduira par un fichier .js qui exporte une fonction d'usine avec l'interface suivante:
export default function ( ) {
return {
imports : { ... } ,
initialize : function ( instance ) { ... }
} ;
} Ici, vous devez instancier le module WebAssembly vous-même; Dans ce cas, vous devez passer imports à titre d'importations, puis immédiatement après son instance, l'appel initialize .
Par exemple, en supposant que vous nommerez votre module généré par le cargo-web en tant que my-module.mjs et my-module.wasm vous pouvez l'instancier comme celui-ci à partir de node.js:
import fs from "fs" ;
import factory from "my-module.mjs" ;
// We read in the `.wasm` module.
const bytecode = fs . readFileSync ( "my-module.wasm" ) ;
const wasm = new WebAssembly . Module ( bytecode ) ;
// We instantiate it.
const instance = factory ( ) ;
const compiled = new WebAssembly . Instance ( wasm , instance . imports ) ;
// This will initialize the module and call your `main`, if you have one.
const exports = instance . initialize ( compiled ) ;
// In the object it returns you can find any functions which
// you've exported with `stdweb`'s `#[js_export]` macro.
console . log ( exports . add ( 1 , 2 ) ) ; Ensuite, vous pouvez l'exécuter avec node --experimental-modules run.mjs .
Ceci est utile si vous souhaitez charger votre fichier .wasm à partir d'une URL personnalisée ou si vous souhaitez intégrer la sortie avec un bundler JavaScript, ou toute autre chose qui vous oblige à charger le module vous-même.
0.6.26--no-default-featuresmime-guess est maintenant utilisée pour deviner les types de mime par le serveur Web intégré0.6.25cargo web start essaiera désormais de ne pas déclencher des reconstructions superflues lorsque les fichiers du projet sont modifiés en succession rapide0.6.24[target.'cfg(...)'.dependencies] sont désormais correctement prises en chargecfg(cargo_web) pour détecter chaque fois que votre caisse est compilée sous cargo-webtarget/wasm32-unknown-unknown/*/deps/*.wasm sont maintenant ignorés; Cela devrait empêcher cargo-web de traiter les artefacts dewasme .wasm générés en raison des dépendances étant également cdylib scargo-web est désormais disponible en bibliothèque via une interface basée sur structopt0.6.23cargo web checkwasm32-unknown-unknown est désormais la valeur par défaut0.6.22deploy peut maintenant être informé où se déployer en utilisant le paramètre -o / --outputAccess-Control-Allow-Origin: * est maintenant toujours envoyé par le serveur Web intégréwasm32-unknown-unknown est maintenant pris en charge à condition qu'un stdweb suffisamment récent soit utilisé0.6.211.38.19 ; Les cibles basées sur l'EMScripten devraient désormais fonctionner à nouveau sur tous les soirswasm32-unknown-unknown sont maintenant triéswasm32-unknown-unknown0.6.20cargo install devrait maintenant fonctionner à nouveaudeploy ne doit pas paniquer lorsqu'il ne trouve pas de cible valide0.6.19cargo install devrait désormais compiler au lieu d'échouer dans certains environnements1.26.20.6.18index.html par défaut n'a plus de nouvelle ligne avant son doctype0.6.171.25.00.6.16wasm32-unknown-unknown utilise désormais WebAssembly.instantiateStreaming lorsqu'il est disponiblewasm32-unknown-unknowncargo-web est redirigéeSous licence sous l'un ou l'autre des
à votre option.
À moins que vous ne soyez explicitement indiqué autrement, toute contribution intentionnellement soumise pour inclusion dans les travaux par vous, telle que définie dans la licence Apache-2.0, doit être autorisée à double licence comme ci-dessus, sans aucune condition supplémentaire.
