diff --git a/__wasm/js-wasm/helloworld/js-wasm/.gitignore b/__wasm/js-wasm/helloworld/js-wasm/.gitignore new file mode 100644 index 0000000..b3822c8 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/.gitignore @@ -0,0 +1,6 @@ +.vscode +target +Cargo.lock +tmp +dist +node_modules diff --git a/__wasm/js-wasm/helloworld/js-wasm/CNAME b/__wasm/js-wasm/helloworld/js-wasm/CNAME new file mode 100644 index 0000000..4936e1e --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/CNAME @@ -0,0 +1 @@ +wasm.js.org \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/LICENSE-APACHE b/__wasm/js-wasm/helloworld/js-wasm/LICENSE-APACHE new file mode 100644 index 0000000..c8e86dd --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright (c) 2019 Richard Anaya + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/LICENSE-MIT b/__wasm/js-wasm/helloworld/js-wasm/LICENSE-MIT new file mode 100644 index 0000000..ebdd1dd --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/LICENSE-MIT @@ -0,0 +1,8 @@ + +Copyright 2020 Richard Anaya + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/Makefile b/__wasm/js-wasm/helloworld/js-wasm/Makefile new file mode 100644 index 0000000..5d3ebad --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/Makefile @@ -0,0 +1,11 @@ +build: + npm run build +build-rs: + cd crates/js-bindgen/ && cargo run -- --language c ../../bindings/web_console.yaml > ../../headers/web_console.h + cd crates/js-bindgen/ && cargo run -- --language c ../../bindings/web_canvas.yaml > ../../headers/web_canvas.h + cd crates/js-bindgen/ && cargo run -- --language c ../../bindings/web_dom.yaml > ../../headers/web_dom.h + cd crates/js-bindgen/ && cargo run -- --language rust ../../bindings/web_console.yaml > ../../crates/web_console/src/lib.rs + cd crates/js-bindgen/ && cargo run -- --language assemblyscript ../../bindings/web_console.yaml > ../../assemblyscript/web_console.ts + cd crates/js-bindgen/ && cargo run -- --language assemblyscript ../../bindings/web_dom.yaml > ../../assemblyscript/web_dom.ts +serve: build + python3 -m http.server \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/README.md b/__wasm/js-wasm/helloworld/js-wasm/README.md new file mode 100644 index 0000000..49e02f4 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/README.md @@ -0,0 +1,100 @@ +# js-wasm +docs.rs docs + +*JavaScript and WebAssembly should be a joy to use together.* + +This project aims to provide a simple, easy to learn, technology-agnostic way bridge the Rust and Javascript using an extremely minimal setup with out-of-box cargo compilation tools. + +See a [demo](https://richardanaya.github.io/js-wasm/examples/snake/index.html) of it working! + +# How It Works? +```bash +cargo new helloworld --lib +cd helloworld +cargo add js +vim src/lib.rs +``` +```rust +use js::*; + +#[no_mangle] +pub fn main() { + // let's dynamically create a javascript function we can invoke to write logs + let fn_log = js!("function(strPtr,strLen){ + console.log(this.readUtf8FromMemory(strPtr,strLen)); + }"); + let msg = "Hello World!"; + fn_log.invoke_2(msg.as_ptr() as u32, msg.len() as u32); +} +``` + +```bash +vim index.html +``` +```html + + + + + + + + Open my console. + + +``` +```bash +vim Cargo.toml +``` +```toml +# add these lines for WebAssembly to end of Cargo.toml + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true +``` +```bash +cargo build --target wasm32-unknown-unknown --release +cp target/wasm32-unknown-unknown/release/helloworld.wasm . +python3 -m http.server + +# open http://localhost:8000 in browser +# right click, inspect, look at message in console +``` + +Full example is [here](https://github.com/richardanaya/js-wasm/tree/master/examples/helloworld). + + +# details +In your JS function context `this` contains several functions handle most issues you'll encounter. It's probably easiest to look at examples to figure out how they are used. + +| Name | Description | +| ------------- | ------------- | +| `readUtf8FromMemory(start,length)` | Extract utf-8 text from your program's memory. | +| `readUtf16FromMemory(start,length)` | Extract utf-16 text from your program's memory. | +| `writeUtf8ToMemory(str)` | Write utf-8 to a memory location you are sure it should go. | +| `readUint8ArrayFromMemory(start)` | Read a list of uint8 from a pointer to a location of a number of elements, followed by a pointer to bytes in memory. | +| `storeObject(object)` | Store an object in your context for later reference, get a handle you can give to WebAssembly. | +| `getObject(handle)` | Retreive and object from your context with a handle. | +| `releaseObject(handle)` | Release a stored object so it's memory can be freed. | +| `createCallback(callbackHandle)` | Creates a callback function that will pass its arguments to the associated WebAssembly function represented by the handle. | +| `module` | Get access to your program so you can call methods on it. | + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `js-wasm` by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/js-wasm.ts b/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/js-wasm.ts new file mode 100644 index 0000000..2582bcd --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/js-wasm.ts @@ -0,0 +1,52 @@ + + +@external("env", "js_register_function") +export declare function js_register_function(codePtr: f64, codeLen: f64, utfByeLen: f64): f64 +@external("env", "js_invoke_function") +export declare function js_invoke_function(fn: f64, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64, g: f64, h: f64, i: f64, j: f64): f64 +@external("env", "js_release") +export declare function js_release(ref: f64): void + +export function js_invoke_function_0(fn: f64): void { + js_invoke_function(fn,0,0,0,0,0,0,0,0,0,0); +} + +export function js_invoke_function_1(fn: f64, a: f64): void { + js_invoke_function(fn,a,0,0,0,0,0,0,0,0,0); +} + +export function js_invoke_function_2(fn: f64, a: f64, b: f64): void { + js_invoke_function(fn,a,b,0,0,0,0,0,0,0,0); +} + +export function js_invoke_function_3(fn: f64, a: f64, b: f64, c: f64): void { + js_invoke_function(fn,a,b,c,0,0,0,0,0,0,0); +} + +export function js_invoke_function_4(fn: f64, a: f64, b: f64, c: f64, d: f64): void { + js_invoke_function(fn,a,b,c,d,0,0,0,0,0,0); +} + +export function js_invoke_function_5(fn: f64, a: f64, b: f64, c: f64, d: f64, e: f64): void { + js_invoke_function(fn,a,b,c,d,e,0,0,0,0,0); +} + +export function js_invoke_function_6(fn: f64, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64): void { + js_invoke_function(fn,a,b,c,d,e,f,0,0,0,0); +} + +export function js_invoke_function_7(fn: f64, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64, g: f64): void { + js_invoke_function(fn,a,b,c,d,e,f,g,0,0,0); +} + +export function js_invoke_function_8(fn: f64, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64, g: f64, h: f64): void { + js_invoke_function(fn,a,b,c,d,e,f,g,h,0,0); +} + +export function js_invoke_function_9(fn: f64, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64, g: f64, h: f64, i: f64): void { + js_invoke_function(fn,a,b,c,d,e,f,g,h,i,0); +} + +export function js_invoke_function_10(fn: f64, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64, g: f64, h: f64, i: f64, j: f64): void { + js_invoke_function(fn,a,b,c,d,e,f,g,h,i,j); +} \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/web_console.ts b/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/web_console.ts new file mode 100644 index 0000000..2eaef3e --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/web_console.ts @@ -0,0 +1,65 @@ +import * as jswasm from "./js-wasm" +let console_clear_fn:f64 = 0; +export function console_clear() : void { + if( console_clear_fn === 0) { + const code = `function(){ console.clear(); }`; + console_clear_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_0(console_clear_fn); +} + +let console_log_fn:f64 = 0; +export function console_log(msg: string) : void { + const a0: f64 = changetype(msg); + const a1: f64 = msg.length*2; + if( console_log_fn === 0) { + const code = `function(msgPtr,msgLen){ console.log(this.readUtf16FromMemory(msgPtr,msgLen)); }`; + console_log_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_2(console_log_fn, a0, a1); +} + +let console_warning_fn:f64 = 0; +export function console_warning(msg: string) : void { + const a0: f64 = changetype(msg); + const a1: f64 = msg.length*2; + if( console_warning_fn === 0) { + const code = `function(msgPtr,msgLen){ console.warn(this.readUtf16FromMemory(msgPtr,msgLen)); }`; + console_warning_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_2(console_warning_fn, a0, a1); +} + +let console_error_fn:f64 = 0; +export function console_error(msg: string) : void { + const a0: f64 = changetype(msg); + const a1: f64 = msg.length*2; + if( console_error_fn === 0) { + const code = `function(msgPtr,msgLen){ console.error(this.readUtf16FromMemory(msgPtr,msgLen)); }`; + console_error_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_2(console_error_fn, a0, a1); +} + +let console_time_fn:f64 = 0; +export function console_time(msg: string) : void { + const a0: f64 = changetype(msg); + const a1: f64 = msg.length*2; + if( console_time_fn === 0) { + const code = `function(msgPtr,msgLen){ console.time(this.readUtf16FromMemory(msgPtr,msgLen)); }`; + console_time_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_2(console_time_fn, a0, a1); +} + +let console_time_end_fn:f64 = 0; +export function console_time_end(msg: string) : void { + const a0: f64 = changetype(msg); + const a1: f64 = msg.length*2; + if( console_time_end_fn === 0) { + const code = `function(msgPtr,msgLen){ console.timeEnd(this.readUtf16FromMemory(msgPtr,msgLen)); }`; + console_time_end_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_2(console_time_end_fn, a0, a1); +} + diff --git a/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/web_dom.ts b/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/web_dom.ts new file mode 100644 index 0000000..bf155e8 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/assemblyscript/web_dom.ts @@ -0,0 +1,12 @@ +import * as jswasm from "./js-wasm" +let document_get_element_by_id_fn:f64 = 0; +export function document_get_element_by_id(id: string) : f64 { + const a0: f64 = changetype(id); + const a1: f64 = id.length*2; + if( document_get_element_by_id_fn === 0) { + const code = `function(idPtr,idLen){ return this.storeObject(document.getElementById(this.readUtf16FromMemory(idPtr,idLen))); }`; + document_get_element_by_id_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + return jswasm.js_invoke_function_2(document_get_element_by_id_fn, a0, a1); +} + diff --git a/__wasm/js-wasm/helloworld/js-wasm/bindings/web_canvas.yaml b/__wasm/js-wasm/helloworld/js-wasm/bindings/web_canvas.yaml new file mode 100644 index 0000000..7b508e3 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/bindings/web_canvas.yaml @@ -0,0 +1,37 @@ +--- +- namespace: canvas + class: CanvasElement + parameter_self: el + method: + - name: getContext + parameters: + - name: contextType + parameter_type: string + +- namespace: canvas + class: CanvasContext + parameter_self: ctx + properties: + - name: fillStyle + property_type: string + methods: + - name: fillRect + parameters: + - name: x + parameter_type: f64 + - name: "y" + parameter_type: f64 + - name: height + parameter_type: f64 + - name: width + parameter_type: f64 + - name: clearRect + parameters: + - name: x + parameter_type: f64 + - name: "y" + parameter_type: f64 + - name: height + parameter_type: f64 + - name: width + parameter_type: f64 \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/bindings/web_console.yaml b/__wasm/js-wasm/helloworld/js-wasm/bindings/web_console.yaml new file mode 100644 index 0000000..5ac52bd --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/bindings/web_console.yaml @@ -0,0 +1,25 @@ +--- +- namespace: console + functions: + - name: clear + - name: log + parameters: + - name: msg + parameter_type: string + - name: warn + friendly_name: warning + parameters: + - name: msg + parameter_type: string + - name: error + parameters: + - name: msg + parameter_type: string + - name: time + parameters: + - name: msg + parameter_type: string + - name: timeEnd + parameters: + - name: msg + parameter_type: string diff --git a/__wasm/js-wasm/helloworld/js-wasm/bindings/web_dom.yaml b/__wasm/js-wasm/helloworld/js-wasm/bindings/web_dom.yaml new file mode 100644 index 0000000..6bab7c3 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/bindings/web_dom.yaml @@ -0,0 +1,8 @@ +--- +- namespace: document + functions: + - name: getElementById + parameters: + - name: id + parameter_type: string + output: object diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/callback/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/callback/Cargo.toml new file mode 100644 index 0000000..5913ecc --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/callback/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "callback" +version = "0.5.4" +authors = ["Richard Anaya"] +edition = "2021" +description = "A library for handling callbacks in WebAssembly" +license = "MIT OR Apache-2.0" +categories = ["wasm", "no-std"] +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" +rust-version="1.62" + +[dependencies] +spin = "0" diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/callback/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/callback/README.md new file mode 100644 index 0000000..c6a85e1 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/callback/README.md @@ -0,0 +1,20 @@ +# callback + +A library for handling callbacks in WebAssembly. + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in 'callback' by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/callback/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/callback/src/lib.rs new file mode 100644 index 0000000..2575e91 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/callback/src/lib.rs @@ -0,0 +1,791 @@ +#![no_std] +#![allow(clippy::type_complexity)] +#![allow(clippy::too_many_arguments)] +extern crate alloc; +use alloc::boxed::Box; +use alloc::sync::Arc; +use alloc::vec::Vec; +use core::{ + future::Future, + pin::Pin, + task::{Context, Poll, Waker}, +}; +use spin::{Mutex, MutexGuard}; + +pub enum CallbackHandler { + Callback0(Box), + Callback1(Box), + Callback2(Box), + Callback3(Box), + Callback4(Box), + Callback5(Box), + Callback6(Box), + Callback7(Box), + Callback8(Box), + Callback9(Box), + Callback10(Box), +} + +type CallbackHandle = f64; + +pub struct CallbackManager { + cur_id: CallbackHandle, + pub keys: Vec, + pub handlers: Vec>>, +} + +fn get_callbacks() -> MutexGuard<'static, CallbackManager> { + static SINGLETON: Mutex = { + Mutex::new(CallbackManager { + cur_id: 0.0, + keys: Vec::new(), + handlers: Vec::new(), + }) + }; + SINGLETON.lock() +} + +pub fn get_callback(id: CallbackHandle) -> Option>> { + let cbs = get_callbacks(); + let index = cbs.keys.iter().position(|&r| r == id); + if let Some(i) = index { + let handler_ref = cbs.handlers.get(i).unwrap().clone(); + core::mem::drop(cbs); + Some(handler_ref) + } else { + None + } +} + +pub fn remove_callback(id: CallbackHandle) { + let mut cbs = get_callbacks(); + let index = cbs.keys.iter().position(|&r| r == id); + if let Some(i) = index { + cbs.keys.remove(i); + cbs.handlers.remove(i); + } +} + +fn create_callback(cb: CallbackHandler) -> f64 { + let mut h = get_callbacks(); + h.cur_id += 1.0; + let id = h.cur_id; + h.keys.push(id); + h.handlers.push(Arc::new(Mutex::new(cb))); + id +} + +pub fn create_callback_0(cb: impl FnMut() + Send + 'static) -> f64 { + create_callback(CallbackHandler::Callback0(Box::new(cb))) +} + +pub fn create_callback_1(cb: impl FnMut(f64) + Send + 'static) -> f64 { + create_callback(CallbackHandler::Callback1(Box::new(cb))) +} + +pub fn create_callback_2(cb: impl FnMut(f64, f64) + Send + 'static) -> f64 { + create_callback(CallbackHandler::Callback2(Box::new(cb))) +} + +pub fn create_callback_3(cb: impl FnMut(f64, f64, f64) + Send + 'static) -> f64 { + create_callback(CallbackHandler::Callback3(Box::new(cb))) +} + +pub fn create_callback_4(cb: impl FnMut(f64, f64, f64, f64) + Send + 'static) -> f64 { + create_callback(CallbackHandler::Callback4(Box::new(cb))) +} + +pub fn create_callback_5(cb: impl FnMut(f64, f64, f64, f64, f64) + Send + 'static) -> f64 { + create_callback(CallbackHandler::Callback5(Box::new(cb))) +} + +pub fn create_callback_6(cb: impl FnMut(f64, f64, f64, f64, f64, f64) + Send + 'static) -> f64 { + create_callback(CallbackHandler::Callback6(Box::new(cb))) +} + +pub fn create_callback_7( + cb: impl FnMut(f64, f64, f64, f64, f64, f64, f64) + Send + 'static, +) -> f64 { + create_callback(CallbackHandler::Callback7(Box::new(cb))) +} + +pub fn create_callback_8( + cb: impl FnMut(f64, f64, f64, f64, f64, f64, f64, f64) + Send + 'static, +) -> f64 { + create_callback(CallbackHandler::Callback8(Box::new(cb))) +} + +pub fn create_callback_9( + cb: impl FnMut(f64, f64, f64, f64, f64, f64, f64, f64, f64) + Send + 'static, +) -> f64 { + create_callback(CallbackHandler::Callback9(Box::new(cb))) +} + +pub fn create_callback_10( + cb: impl FnMut(f64, f64, f64, f64, f64, f64, f64, f64, f64, f64) + Send + 'static, +) -> f64 { + create_callback(CallbackHandler::Callback10(Box::new(cb))) +} + +pub struct CallbackFuture { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState { + completed: bool, + waker: Option, + result: Option, +} + +impl Future for CallbackFuture { + type Output = Option; + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture { + pub fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState { + completed: false, + waker: None, + result: None, + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback1(Box::new(move |v: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = Some(v); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }))); + (CallbackFuture { shared_state }, id as f64) + } +} + +struct CallbackFuture0 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState0 { + completed: bool, + waker: Option, + result: (), +} + +impl Future for CallbackFuture0 { + type Output = (); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(()) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture0 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState0 { + completed: false, + waker: None, + result: (), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback0(Box::new(move || { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }))); + (CallbackFuture0 { shared_state }, id) + } +} + +pub fn create_callback_future_0() -> (impl Future, f64) { + CallbackFuture0::new() +} + +struct CallbackFuture1 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState1 { + completed: bool, + waker: Option, + result: f64, +} + +impl Future for CallbackFuture1 { + type Output = f64; + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture1 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState1 { + completed: false, + waker: None, + result: 0.0, + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback1(Box::new(move |v: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = v; + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }))); + (CallbackFuture1 { shared_state }, id) + } +} + +pub fn create_callback_future_1() -> (impl Future, f64) { + CallbackFuture1::new() +} + +struct CallbackFuture2 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState2 { + completed: bool, + waker: Option, + result: (f64, f64), +} + +impl Future for CallbackFuture2 { + type Output = (f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture2 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState2 { + completed: false, + waker: None, + result: (0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback2(Box::new( + move |a1: f64, a2: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture2 { shared_state }, id) + } +} + +pub fn create_callback_future_2() -> (impl Future, f64) { + CallbackFuture2::new() +} + +struct CallbackFuture3 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState3 { + completed: bool, + waker: Option, + result: (f64, f64, f64), +} + +impl Future for CallbackFuture3 { + type Output = (f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture3 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState3 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback3(Box::new( + move |a1: f64, a2: f64, a3: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture3 { shared_state }, id) + } +} + +pub fn create_callback_future_3() -> (impl Future, f64) { + CallbackFuture3::new() +} + +struct CallbackFuture4 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState4 { + completed: bool, + waker: Option, + result: (f64, f64, f64, f64), +} + +impl Future for CallbackFuture4 { + type Output = (f64, f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture4 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState4 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback4(Box::new( + move |a1: f64, a2: f64, a3: f64, a4: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3, a4); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture4 { shared_state }, id) + } +} + +pub fn create_callback_future_4() -> (impl Future, f64) { + CallbackFuture4::new() +} + +struct CallbackFuture5 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState5 { + completed: bool, + waker: Option, + result: (f64, f64, f64, f64, f64), +} + +impl Future for CallbackFuture5 { + type Output = (f64, f64, f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture5 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState5 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback5(Box::new( + move |a1: f64, a2: f64, a3: f64, a4: f64, a5: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3, a4, a5); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture5 { shared_state }, id) + } +} + +pub fn create_callback_future_5() -> (impl Future, f64) { + CallbackFuture5::new() +} + +struct CallbackFuture6 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState6 { + completed: bool, + waker: Option, + result: (f64, f64, f64, f64, f64, f64), +} + +impl Future for CallbackFuture6 { + type Output = (f64, f64, f64, f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture6 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState6 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0, 0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback6(Box::new( + move |a1: f64, a2: f64, a3: f64, a4: f64, a5: f64, a6: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3, a4, a5, a6); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture6 { shared_state }, id) + } +} + +pub fn create_callback_future_6() -> (impl Future, f64) { + CallbackFuture6::new() +} + +struct CallbackFuture7 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState7 { + completed: bool, + waker: Option, + result: (f64, f64, f64, f64, f64, f64, f64), +} + +impl Future for CallbackFuture7 { + type Output = (f64, f64, f64, f64, f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture7 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState7 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback7(Box::new( + move |a1: f64, a2: f64, a3: f64, a4: f64, a5: f64, a6: f64, a7: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3, a4, a5, a6, a7); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture7 { shared_state }, id) + } +} + +pub fn create_callback_future_7() -> (impl Future, f64) { + CallbackFuture7::new() +} + +struct CallbackFuture8 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState8 { + completed: bool, + waker: Option, + result: (f64, f64, f64, f64, f64, f64, f64, f64), +} + +impl Future for CallbackFuture8 { + type Output = (f64, f64, f64, f64, f64, f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture8 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState8 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback8(Box::new( + move |a1: f64, a2: f64, a3: f64, a4: f64, a5: f64, a6: f64, a7: f64, a8: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3, a4, a5, a6, a7, a8); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture8 { shared_state }, id) + } +} + +pub fn create_callback_future_8() -> (impl Future, f64) { + CallbackFuture8::new() +} + +struct CallbackFuture9 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState9 { + completed: bool, + waker: Option, + result: (f64, f64, f64, f64, f64, f64, f64, f64, f64), +} + +impl Future for CallbackFuture9 { + type Output = (f64, f64, f64, f64, f64, f64, f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture9 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState9 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback9(Box::new( + move |a1: f64, + a2: f64, + a3: f64, + a4: f64, + a5: f64, + a6: f64, + a7: f64, + a8: f64, + a9: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3, a4, a5, a6, a7, a8, a9); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture9 { shared_state }, id) + } +} + +pub fn create_callback_future_9() -> (impl Future, f64) { + CallbackFuture9::new() +} + +struct CallbackFuture10 { + shared_state: Arc>, +} + +/// Shared state between the future and the waiting thread +struct SharedState10 { + completed: bool, + waker: Option, + result: (f64, f64, f64, f64, f64, f64, f64, f64, f64, f64), +} + +impl Future for CallbackFuture10 { + type Output = (f64, f64, f64, f64, f64, f64, f64, f64, f64, f64); + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut shared_state = self.shared_state.lock(); + if shared_state.completed { + Poll::Ready(shared_state.result) + } else { + shared_state.waker = Some(cx.waker().clone()); + Poll::Pending + } + } +} + +impl CallbackFuture10 { + fn new() -> (Self, f64) { + let shared_state = Arc::new(Mutex::new(SharedState10 { + completed: false, + waker: None, + result: (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), + })); + + let thread_shared_state = shared_state.clone(); + let id = create_callback(CallbackHandler::Callback10(Box::new( + move |a1: f64, + a2: f64, + a3: f64, + a4: f64, + a5: f64, + a6: f64, + a7: f64, + a8: f64, + a9: f64, + a10: f64| { + let mut shared_state = thread_shared_state.lock(); + shared_state.completed = true; + shared_state.result = (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + if let Some(waker) = shared_state.waker.take() { + core::mem::drop(shared_state); + waker.wake() + } + }, + ))); + (CallbackFuture10 { shared_state }, id) + } +} + +pub fn create_callback_future_10() -> (impl Future, f64) { + CallbackFuture10::new() +} + +#[no_mangle] +fn handle_callback( + id: f64, + a1: f64, + a2: f64, + a3: f64, + a4: f64, + a5: f64, + a6: f64, + a7: f64, + a8: f64, + a9: f64, + a10: f64, +) { + let h = get_callback(id); + let handler_ref = h.unwrap(); + let mut handler = handler_ref.lock(); + match &mut *handler { + CallbackHandler::Callback0(c) => c(), + CallbackHandler::Callback1(c) => c(a1), + CallbackHandler::Callback2(c) => c(a1, a2), + CallbackHandler::Callback3(c) => c(a1, a2, a3), + CallbackHandler::Callback4(c) => c(a1, a2, a3, a4), + CallbackHandler::Callback5(c) => c(a1, a2, a3, a4, a5), + CallbackHandler::Callback6(c) => c(a1, a2, a3, a4, a5, a6), + CallbackHandler::Callback7(c) => c(a1, a2, a3, a4, a5, a6, a7), + CallbackHandler::Callback8(c) => c(a1, a2, a3, a4, a5, a6, a7, a8), + CallbackHandler::Callback9(c) => c(a1, a2, a3, a4, a5, a6, a7, a8, a9), + CallbackHandler::Callback10(c) => c(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/Cargo.toml new file mode 100644 index 0000000..de1815e --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "cargo-webassembly" +version = "0.0.18" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "A cargo utility for working on WebAssembly" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +url= "2.2.0" +webbrowser = "0.5.5" +clap = { version = "2.33.3", features = ["yaml"] } +colored = "2.0.0" +tide = "0.15.0" +async-std = { version = "1.7.0", features = ["attributes"] } diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/README.md new file mode 100644 index 0000000..7376b98 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/README.md @@ -0,0 +1,78 @@ +# cargo-webassembly + +This cargo extension is for developing front end applications in WebAssembly. Use it's subcommands to generate Rust projects ready to develop WebAssembly immediately, and use the tool to run a local dev server to see it while you work. + +This project is currently **beta**, but totally functional! Next steps include: + +* cleaning up the code to use less `unwrap` +* use a better open url library (the current one has some weird behavior). +* support project file watching and recompiling + +

+ +

+ +First make sure you [install Rust](https://rustup.rs/) and have the `wasm32` toolchain installed: + +``` +rustup target add wasm32-unknown-unknown +``` + +Install with the following command: + +``` +cargo install cargo-webassembly +``` + +# Create a new project + +``` +cargo webassembly new my_project +``` + +This will initialize a Rust WebAssembly project completely setup to run in the browser. + +# Run your project + +Go into your projects root directory (e.g. `cd my_project`) + +``` +cargo webassembly run +``` + +This will compile and start a server by default on port `8080`, you can change the port with the `-p` option. + +This server is setup for single-page apps where all non-static file routes redirect to the root `index.html`. + +# Building your project + +``` +cargo webassembly build +``` + +This command will just compile your WebAssembly and place everything you need for your web app in the `dist` folder. + +# Next steps + +Check out more ways to interact with the browser using the [`web`](https://docs.rs/web/) package! + +Here's some cool examples: + +* [snake](https://wasm.js.org/examples/snake/) + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `cargo-webassembly` by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/cli.yaml b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/cli.yaml new file mode 100644 index 0000000..5871a8d --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/cli.yaml @@ -0,0 +1,29 @@ +name: cargo-webassembly +version: "0.0.12" +author: Richard Anaya +about: A tool for working with WebAssembly Rust projects +subcommands: + - webassembly: + args: + - version: + short: V + multiple: true + help: Displays the version + about: A collection of subcommands for working with WebAssembly + subcommands: + - new: + about: creates new WebAssembly project + args: + - INPUT: + help: Sets the name of the project directory to use + required: true + - init: + about: creates new WebAssembly project in current directory + - build: + about: controls testing features + - run: + about: controls testing features + args: + - port: + help: Sets the port to be used when running + default_value: "8080" \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/main.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/main.rs new file mode 100644 index 0000000..0694f41 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/main.rs @@ -0,0 +1,213 @@ +#[macro_use] +extern crate clap; +use clap::App; +extern crate url; +use colored::*; +use std::env; +use std::fs::create_dir; +use std::path::PathBuf; + +pub fn from_extension(extension: impl AsRef) -> Option { + match extension.as_ref() { + "html" => Some(tide::http::mime::HTML), + "js" | "mjs" | "jsonp" => Some(tide::http::mime::JAVASCRIPT), + "json" => Some(tide::http::mime::JSON), + "css" => Some(tide::http::mime::CSS), + "svg" => Some(tide::http::mime::SVG), + "xml" => Some(tide::http::mime::XML), + "png" => Some(tide::http::mime::PNG), + "jpg" | "jpeg" => Some(tide::http::mime::JPEG), + "wasm" => Some(tide::http::mime::WASM), + "ico" => Some(tide::http::mime::ICO), + _ => None, + } +} + +#[async_std::main] +async fn main() -> tide::Result<()> { + let yaml = load_yaml!("cli.yaml"); + let mut app = App::from_yaml(yaml); + let matches = app.clone().get_matches(); + + let mut dir = env::current_dir().unwrap(); + + if let Some(matches) = matches.subcommand_matches("webassembly") { + if let Some(matches) = matches.subcommand_matches("new") { + dir = dir.join(matches.value_of("INPUT").unwrap()); + create_project_in_dir(&dir) + } else if let Some(_) = matches.subcommand_matches("init") { + create_project_in_dir(&dir) + } else if let Some(_) = matches.subcommand_matches("build") { + build_project_in_dir(&dir) + } else if let Some(matches) = matches.subcommand_matches("run") { + build_project_in_dir(&dir); + let name = dir.file_name().unwrap().to_str().unwrap(); + let server_dir = dir.join("dist"); + let mut app = tide::new(); + let server_dir2 = server_dir.clone(); + app.at("/").get(move |_req: tide::Request<()>| { + let index = server_dir.join("index.html"); + async move { + tide::Result::Ok( + tide::Response::builder(200) + .body(std::fs::read(index).unwrap()) + .content_type(tide::http::mime::HTML) + .build(), + ) + } + }); + app.at("/*").get(move |req: tide::Request<()>| { + let server_dir3 = server_dir2.clone(); + async move { + let index = server_dir3.join("index.html"); + let p = server_dir3.to_str().unwrap(); + let p2 = req.url().path(); + let s = format!("{}{}", p, p2).to_string(); + let p3 = std::path::Path::new(&s); + if p3.exists() { + tide::Result::Ok( + tide::Response::builder(200) + .body(std::fs::read(p3).unwrap()) + .content_type( + from_extension(p3.extension().unwrap().to_str().unwrap()) + .unwrap(), + ) + .build(), + ) + } else { + tide::Result::Ok( + tide::Response::builder(200) + .body(std::fs::read(index).unwrap()) + .content_type(tide::http::mime::HTML) + .build(), + ) + } + } + }); + let port = matches.value_of("port").unwrap().parse::().unwrap(); + let addr = format!("{}{}", "http://127.0.0.1:", port); + let addr2 = addr.clone(); + async_std::task::spawn(async move { webbrowser::open(&addr2) }); + println!( + " {} webassembly `{}` package on port {}", + "Running".green().bold(), + name, + addr + ); + app.listen(addr).await?; + } else { + if matches.is_present("version") { + println!("{}", env!("CARGO_PKG_VERSION")) + } else { + app.print_long_help().unwrap(); + } + } + } + Ok(()) +} + +fn create_project_in_dir(dir: &PathBuf) { + let name = dir.file_name().unwrap().to_str().unwrap(); + if !dir.exists() { + create_dir(dir).unwrap(); + } + create_dir(dir.join("src")).unwrap(); + create_dir(dir.join("dist")).unwrap(); + std::fs::write( + dir.join("Cargo.toml"), + include_str!("template/Project.toml").replace("PROJECT", name), + ) + .expect("Failed to write"); + std::fs::write( + dir.join("src/lib.rs"), + include_str!("template/lib.rs").replace("PROJECT", name), + ) + .expect("Failed to write"); + std::fs::write( + dir.join("dist/index.html"), + include_str!("template/index.html").replace("PROJECT", name), + ) + .expect("Failed to write"); + std::fs::write( + dir.join("dist/js-wasm.js"), + include_str!("template/js-wasm.js").replace("PROJECT", name), + ) + .expect("Failed to write"); + println!( + " {} webassembly `{}` package", + "Created".green().bold(), + name + ); +} + +fn build_project_in_dir(dir: &PathBuf) { + use std::io::{self, Write}; + use std::process::Command; + + if !dir.join("Cargo.toml").exists() { + println!("must execute this command in project root"); + return; + } + + let name = dir.file_name().unwrap().to_str().unwrap(); + println!( + " {} webassembly `{}` package", + "Pre-compile check".green().bold(), + name + ); + let mut target_check = Command::new("cargo"); + target_check + .arg("check") + .arg("--target") + .arg("wasm32-unknown-unknown"); + let command_output = target_check + .output() + .expect("Build pre-check failed! (check that wasm32 build target is installed)"); + io::stdout().write_all(&command_output.stdout).unwrap(); + io::stderr().write_all(&command_output.stderr).unwrap(); + println!( + " Pre-compile check exit code status: {}", + command_output.status + ); + + let name = dir.file_name().unwrap().to_str().unwrap(); + println!( + " {} webassembly `{}` package", + "Compiling".green().bold(), + name + ); + + println!( + " {} webassembly `{}` package", + "Compiling".green().bold(), + name + ); + let mut echo_hello = Command::new("cargo"); + echo_hello + .arg("build") + .arg("--target") + .arg("wasm32-unknown-unknown") + .arg("--release"); + let compile_command_output = echo_hello.output().expect("Could not compile to wasm"); + + io::stdout() + .write_all(&compile_command_output.stdout) + .unwrap(); + io::stderr() + .write_all(&compile_command_output.stderr) + .unwrap(); + println!( + " Compilation exit code status: {}", + compile_command_output.status + ); + + std::fs::copy( + dir.join(format!( + "target/wasm32-unknown-unknown/release/{}.wasm", + name.replace("-", "_") + )), + dir.join(format!("dist/{}.wasm", name)), + ) + .expect("Could not copy built file! (check that wasm32 build target is installed)"); + println!(" {} webassembly target", "Finished".green().bold()); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/Project.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/Project.toml new file mode 100644 index 0000000..240d11b --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/Project.toml @@ -0,0 +1,18 @@ +[package] +name = "PROJECT" +version = "0.0.0" +authors = [""] +edition = "2018" +description = "" +categories = ["wasm"] + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +web = "0" + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/index.html b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/index.html new file mode 100644 index 0000000..8e4ea0d --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/index.html @@ -0,0 +1,11 @@ + + + + PROJECT + + + + + + + \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/js-wasm.js b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/js-wasm.js new file mode 100644 index 0000000..e57f02d --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/js-wasm.js @@ -0,0 +1,304 @@ +class Index { + constructor(index, generation) { + this.index = index; + this.generation = generation; + } + + toNum() { + return Number(BigInt(this.generation) << BigInt(32) | BigInt(this.index)); + } +} + +Index.fromNum = function (n) { + let i = Number(((BigInt(n) & BigInt(0xffffffff00000000)) >> BigInt(32)) & BigInt(0xffffffff)); + let g = n & 0xffffffff; + return new Index(g, i); +}; + +class GenerationalArena { + constructor() { + this.items = []; + this.generation = 0; + this.free_list_head = null; + this.length = 0; + } + + insert(v) { + // lets use the first free entry if we have one + if (this.free_list_head !== null) { + let i = this.free_list_head; + this.free_list_head = this.items[i].next_free; + this.items[i] = { + generation: this.generation, + value: v + }; + this.length += 1; + return new Index(i, this.generation); + } + + this.items.push({ + generation: this.generation, + value: v + }); + let idx = new Index(this.items.length - 1, this.generation); + this.length += 1; + return idx; + } + + contains(idx) { + return this.get(idx) !== undefined; + } + + get(i) { + let e = this.items[i.index]; + if (e && e.generation === i.generation) { + return e.value; + } + return undefined; + } + + remove(idx) { + if (idx.index >= this.items.length) { + return undefined; + } + + let e = this.items[idx.index]; + if (e.generation !== undefined && e.generation == idx.generation) { + this.generation += 1; + this.items[idx.index] = { + next_free: this.free_list_head + }; + this.free_list_head = idx.index; + this.length -= 1; + return e.value; + } + return undefined; + } + + *[Symbol.iterator]() { + for (var i = 0; i < this.items.length; i++) { + let x = this.items[i]; + if (x.generation !== undefined) { + yield { index: new Index(i, x.generation), value: x.value }; + } + } + } + + indices() { + let i = { items: this.items }; + i[Symbol.iterator] = function* iter() { + for (var i = 0; i < this.items.length; i++) { + let x = this.items[i]; + if (x.generation !== undefined) { + yield new Index(i, x.generation); + } + } + }; + return i; + } + + values() { + let i = { items: this.items }; + i[Symbol.iterator] = function* iter() { + for (var i = 0; i < this.items.length; i++) { + let x = this.items[i]; + if (x.generation !== undefined) { + yield x.value; + } + } + }; + return i; + } +} + +window.JsWasm = { + createEnvironment() { + let arena = new GenerationalArena(); + arena.insert(undefined); + arena.insert(null); + arena.insert(self); + arena.insert(typeof document != "undefined" ? document : null); + arena.insert(typeof document != "undefined" ? document.body : null); + let context = { + functions: [ + function () { + debugger; + } + ], + objects: arena, + utf8dec: new TextDecoder("utf-8"), + utf8enc: new TextEncoder("utf-8"), + utf16dec: new TextDecoder("utf-16"), + utf16enc: new TextEncoder("utf-16"), + toCallbackArg: function (arg) { + if (typeof arg === "object") { + return context.storeObject(arg); + } + return arg; + }, + createCallback: function (cb) { + let fnHandleCallback = this.module.instance.exports.handle_callback; + return function () { + const arg = arguments; + fnHandleCallback( + cb, + context.toCallbackArg(arg[0]), + context.toCallbackArg(arg[1]), + context.toCallbackArg(arg[2]), + context.toCallbackArg(arg[3]), + context.toCallbackArg(arg[4]), + context.toCallbackArg(arg[5]), + context.toCallbackArg(arg[6]), + context.toCallbackArg(arg[7]), + context.toCallbackArg(arg[8]), + context.toCallbackArg(arg[9]) + ); + }; + }, + readCStringFromMemory: function (start) { + const data = new Uint8Array(this.module.instance.exports.memory.buffer); + const str = []; + let i = start; + while (data[i] !== 0) { + str.push(data[i]); + i++; + } + return this.utf8dec.decode(new Uint8Array(str)); + }, + writeCStringToMemory(str) { + const bytes = this.utf8enc.encode(str + String.fromCharCode(0)); + const len = bytes.length; + const start = this.module.instance.exports.malloc(len); + const memory = new Uint8Array( + this.module.instance.exports.memory.buffer + ); + memory.set(bytes, start); + return start; + }, + readUtf8FromMemory: function (start, len) { + const memory = new Uint8Array( + this.module.instance.exports.memory.buffer + ); + const text = this.utf8dec.decode(memory.subarray(start, start + len)); + return text; + }, + writeUtf8ToMemory: function (str) { + const bytes = utf8enc.encode(str); + const len = bytes.length; + const start = this.module.instance.exports.malloc(len); + const memory = new Uint8Array( + this.module.instance.exports.memory.buffer + ); + memory.set(bytes, start); + return start; + }, + readUtf16FromMemory: function (start, len) { + const memory = new Uint8Array( + this.module.instance.exports.memory.buffer + ); + const text = this.utf16dec.decode(memory.subarray(start, start + len)); + return text; + }, + writeUtf16ToMemory: function (str) { + const bytes = utf16enc.encode(str); + const len = bytes.length; + const start = this.module.instance.exports.malloc(len); + const memory = new Uint8Array( + this.module.instance.exports.memory.buffer + ); + memory.set(bytes, start); + return start; + }, + readUint8ArrayFromMemory(start) { + const data32 = new Uint32Array( + this.module.instance.exports.memory.buffer + ); + const ptr = data32[start / 4]; + const length = data32[ptr / 4]; + let b = mem.slice(ptr + 4, ptr + 4 + length); + return new Uint8Array(b); + }, + storeObject: function (obj) { + const index = this.objects.insert(obj); + return index.toNum(); + }, + getObject: function (handle) { + return this.objects.get(Index.fromNum(handle)); + }, + releaseObject: function (handle) { + this.objects.remove(Index.fromNum(handle)); + } + }; + return { + context, + abort() { + throw new Error("WebAssembly module aborted"); + }, + js_release(obj) { + context.releaseObject(obj); + }, + js_register_function(start, len, utfByteLen) { + let functionBody; + if (utfByteLen === 16) { + functionBody = context.readUtf16FromMemory(start, len); + } else { + functionBody = context.readUtf8FromMemory(start, len); + } + let id = context.functions.length; + context.functions.push( + Function(`"use strict";return(${functionBody})`)() + ); + return id; + }, + js_invoke_function(funcHandle, a, b, c, d, e, f, g, h, i, j) { + return context.functions[funcHandle].call( + context, + a, + b, + c, + d, + e, + f, + g, + h, + i, + j + ); + } + }; + }, + + async load_and_run_wasm(wasmURL) { + const env = JsWasm.createEnvironment(); + const response = await fetch(wasmURL); + const bytes = await response.arrayBuffer(); + const module = await WebAssembly.instantiate(bytes, { + env + }); + env.context.module = module; + module.instance.exports.main(); + } +}; + +document.addEventListener("DOMContentLoaded", function () { + const wasmScripts = document.querySelectorAll( + "script[type='application/wasm']" + ); + for (let i = 0; i < wasmScripts.length; i++) { + const src = wasmScripts[i].src; + if (src) { + JsWasm.load_and_run_wasm(src); + } else { + console.error("Script tag must have 'src' property."); + } + } +}); + +if (window.WasmScriptComponents) { + window.WasmScriptComponents["js-wasm"] = function (e) { + return { + ...e, + ...JsWasm.createEnvironment() + }; + }; +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/lib.rs new file mode 100644 index 0000000..880558e --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cargo-webassembly/src/template/lib.rs @@ -0,0 +1,6 @@ +use web::*; + +#[no_mangle] +pub fn main() { + set_inner_html(DOM_BODY,"Hello World!"); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/Cargo.toml new file mode 100644 index 0000000..9076dfa --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "class_names" +version = "0.0.2" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "A macro library for elegantly joining class names for web frameworks" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/README.md new file mode 100644 index 0000000..33fa72c --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/README.md @@ -0,0 +1,46 @@ +# class_names + +docs.rs docs + +```toml +[dependencies] +class_names="0" +``` + +# How to use + +This library includes a macro for easily expressing a list of CSS class names (some which may be optional). The macro takes in a mixed list of `&str`,`String`,`Option<&str>`, or `Option` and calculates a final list of class names for the HTML `class` attribute. Here's some examples + +1. use strings +```rust +class_names!("big-button", "red".to_string()) // "big-button red" +``` +2. accepts optionals +```rust +class_names!("big-button", if btn_red { Some("red") } else { None } ) +``` +3. a concise way of writing an optional +```rust +class_names!("big-button", btn_inactive.then(|| "inactive")) +``` +4. one day from future features in [Rust nightly](https://doc.rust-lang.org/std/primitive.bool.html#method.then_some) you'll be able to write like this +```rust +class_names!("big-button", btn_inactive.then_some("inactive")) +``` + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `class_names` by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/src/lib.rs new file mode 100644 index 0000000..c0ea4a6 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/class_names/src/lib.rs @@ -0,0 +1,75 @@ +#![no_std] +use core::cell::RefCell; +extern crate alloc; +use alloc::string::String; +use alloc::vec::Vec; + +pub trait AddClassList<'a> { + fn insert_into_list(&'a self, list: &'a ClassList<'a>); +} + +impl<'a> AddClassList<'a> for &str { + fn insert_into_list(&'a self, list: &'a ClassList<'a>) { + list.classes.borrow_mut().push(self); + } +} + +impl<'a> AddClassList<'a> for Option<&str> { + fn insert_into_list(&'a self, list: &'a ClassList<'a>) { + match self { + Some(t) => list.classes.borrow_mut().push(t), + None => (), + }; + } +} + +impl<'a> AddClassList<'a> for Option { + fn insert_into_list(&'a self, list: &'a ClassList<'a>) { + match self { + Some(t) => list.classes.borrow_mut().push(&t), + None => (), + }; + } +} + +impl<'a> AddClassList<'a> for String { + fn insert_into_list(&'a self, list: &'a ClassList<'a>) { + list.classes.borrow_mut().push(&self); + } +} + +pub struct ClassList<'a> { + classes: RefCell>, +} + +impl<'a> ClassList<'a> { + pub fn new() -> ClassList<'a> { + ClassList { + classes: RefCell::new(Vec::new()), + } + } + pub fn add(&'a self, item: &'a T) + where + T: AddClassList<'a>, + { + (&item).insert_into_list(self); + } + pub fn to_string(&self) -> String { + self.classes.borrow_mut().join(" ") + } +} + +#[macro_export] +macro_rules! class_names { + // `()` indicates that the macro takes no argument. + ($($element:expr),*) => { + { + let class_list = ClassList::new(); + $( + let e = $element; + class_list.add(&e); + )* + class_list.to_string() + } + }; +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/Cargo.toml new file mode 100644 index 0000000..1bf7fde --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "cstring" +version = "0.1.1" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "A super simple cstring library for WebAssembly" +categories = ["wasm", "no-std"] + +[dependencies] +cty = "0.2.1" +memchr = { version = "2.3.4", default-features = false } + +[features] +default = ["alloc"] +alloc = [] diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/README.md new file mode 100644 index 0000000..fa0c570 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/README.md @@ -0,0 +1,15 @@ +# cstring +A super simple library for c strings in web assembly + +```toml +[dependencies] +cstring = "0.0.4" +``` + +# javascript + +I've also included a very useful es6 module for interacting with strings in web assembly memory + +```javascript +import { extractCString, insertString } from "https://cdn.jsdelivr.net/gh/richardanaya/cstring/cstring.js"; +``` diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/cstring.js b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/cstring.js new file mode 100644 index 0000000..89dfd50 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/cstring.js @@ -0,0 +1,22 @@ +const utf8dec = new TextDecoder("utf-8"); +const utf8enc = new TextEncoder("utf-8"); + +export function extractCString(mem, ptr) { + const memory = new Uint8Array(mem); + const str = []; + let i = ptr; + while (memory[i] !== 0) { + str.push(memory[i]); + i++; + } + return utf8dec.decode(new Uint8Array(str)); +} + +export function insertString(getMemory, malloc, str) { + const bytes = utf8enc.encode(str); + const len = bytes.length; + const start = malloc(len); + const memory = new Uint8Array(getMemory()); + memory.set(bytes, start); + return [start, len]; +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/src/cstr_core.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/src/cstr_core.rs new file mode 100644 index 0000000..5b212b4 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/src/cstr_core.rs @@ -0,0 +1,1377 @@ +// This code comes from the unupdated project https://github.com/Amanieu/cstr_core + +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[cfg(test)] +#[macro_use] +extern crate std; + +#[cfg(feature = "alloc")] +extern crate alloc; +extern crate cty; +extern crate memchr; + +#[cfg(feature = "alloc")] +use alloc::borrow::{Borrow, Cow, ToOwned}; +#[cfg(feature = "alloc")] +use alloc::boxed::Box; +#[cfg(feature = "alloc")] +use alloc::rc::Rc; +#[cfg(feature = "alloc")] +use alloc::string::String; +#[cfg(feature = "alloc")] +use alloc::sync::Arc; +#[cfg(feature = "alloc")] +use alloc::vec::Vec; +#[cfg(feature = "alloc")] +use core::{mem, ops, ptr}; + +use core::cmp::Ordering; +use core::fmt::{self, Write}; +use core::slice; +use core::str::{self, Utf8Error}; + +/// Re-export c_char +pub use cty::c_char; + +#[inline] +unsafe fn strlen(p: *const c_char) -> usize { + let mut n = 0; + while *p.offset(n as isize) != 0 { + n += 1; + } + n +} + +mod ascii { + use core::ops::Range; + + /// An iterator over the escaped version of a byte. + /// + /// This `struct` is created by the [`escape_default`] function. See its + /// documentation for more. + /// + /// [`escape_default`]: fn.escape_default.html + pub struct EscapeDefault { + range: Range, + data: [u8; 4], + } + + /// Returns an iterator that produces an escaped version of a `u8`. + /// + /// The default is chosen with a bias toward producing literals that are + /// legal in a variety of languages, including C++11 and similar C-family + /// languages. The exact rules are: + /// + /// - Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively. + /// - Single-quote, double-quote and backslash chars are backslash-escaped. + /// - Any other chars in the range [0x20,0x7e] are not escaped. + /// - Any other chars are given hex escapes of the form '\xNN'. + /// - Unicode escapes are never generated by this function. + /// + /// # Examples + /// + /// ``` + /// use std::ascii; + /// + /// let escaped = ascii::escape_default(b'0').next().unwrap(); + /// assert_eq!(b'0', escaped); + /// + /// let mut escaped = ascii::escape_default(b'\t'); + /// + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// assert_eq!(b't', escaped.next().unwrap()); + /// + /// let mut escaped = ascii::escape_default(b'\r'); + /// + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// assert_eq!(b'r', escaped.next().unwrap()); + /// + /// let mut escaped = ascii::escape_default(b'\n'); + /// + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// assert_eq!(b'n', escaped.next().unwrap()); + /// + /// let mut escaped = ascii::escape_default(b'\''); + /// + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// assert_eq!(b'\'', escaped.next().unwrap()); + /// + /// let mut escaped = ascii::escape_default(b'"'); + /// + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// assert_eq!(b'"', escaped.next().unwrap()); + /// + /// let mut escaped = ascii::escape_default(b'\\'); + /// + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// + /// let mut escaped = ascii::escape_default(b'\x9d'); + /// + /// assert_eq!(b'\\', escaped.next().unwrap()); + /// assert_eq!(b'x', escaped.next().unwrap()); + /// assert_eq!(b'9', escaped.next().unwrap()); + /// assert_eq!(b'd', escaped.next().unwrap()); + /// ``` + pub fn escape_default(c: u8) -> EscapeDefault { + let (data, len) = match c { + b'\t' => ([b'\\', b't', 0, 0], 2), + b'\r' => ([b'\\', b'r', 0, 0], 2), + b'\n' => ([b'\\', b'n', 0, 0], 2), + b'\\' => ([b'\\', b'\\', 0, 0], 2), + b'\'' => ([b'\\', b'\'', 0, 0], 2), + b'"' => ([b'\\', b'"', 0, 0], 2), + b'\x20'..=b'\x7e' => ([c, 0, 0, 0], 1), + _ => ([b'\\', b'x', hexify(c >> 4), hexify(c & 0xf)], 4), + }; + + return EscapeDefault { + range: (0..len), + data: data, + }; + + fn hexify(b: u8) -> u8 { + match b { + 0..=9 => b'0' + b, + _ => b'a' + b - 10, + } + } + } + + impl Iterator for EscapeDefault { + type Item = u8; + fn next(&mut self) -> Option { + self.range.next().map(|i| self.data[i]) + } + fn size_hint(&self) -> (usize, Option) { + self.range.size_hint() + } + } + impl DoubleEndedIterator for EscapeDefault { + fn next_back(&mut self) -> Option { + self.range.next_back().map(|i| self.data[i]) + } + } + impl ExactSizeIterator for EscapeDefault {} +} + +/// A type representing an owned C-compatible string. +/// +/// This type serves the primary purpose of being able to safely generate a +/// C-compatible string from a Rust byte slice or vector. An instance of this +/// type is a static guarantee that the underlying bytes contain no interior 0 +/// bytes and the final byte is 0. +/// +/// A `CString` is created from either a byte slice or a byte vector. A [`u8`] +/// slice can be obtained with the `as_bytes` method. Slices produced from a +/// `CString` do *not* contain the trailing nul terminator unless otherwise +/// specified. +/// +/// [`u8`]: ../primitive.u8.html +/// +/// # Examples +/// +/// ```ignore (extern-declaration) +/// # fn main() { +/// use cstr_core::CString; +/// use cstr_core::c_char; +/// +/// extern { +/// fn my_printer(s: *const c_char); +/// } +/// +/// let c_to_print = CString::new("Hello, world!").unwrap(); +/// unsafe { +/// my_printer(c_to_print.as_ptr()); +/// } +/// # } +/// ``` +/// +/// # Safety +/// +/// `CString` is intended for working with traditional C-style strings +/// (a sequence of non-null bytes terminated by a single null byte); the +/// primary use case for these kinds of strings is interoperating with C-like +/// code. Often you will need to transfer ownership to/from that external +/// code. It is strongly recommended that you thoroughly read through the +/// documentation of `CString` before use, as improper ownership management +/// of `CString` instances can lead to invalid memory accesses, memory leaks, +/// and other memory errors. + +#[cfg(feature = "alloc")] +#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Clone)] +pub struct CString { + // Invariant 1: the slice ends with a zero byte and has a length of at least one. + // Invariant 2: the slice contains only one zero byte. + // Improper usage of unsafe function can break Invariant 2, but not Invariant 1. + inner: Box<[u8]>, +} + +/// Representation of a borrowed C string. +/// +/// This dynamically sized type is only safely constructed via a borrowed +/// version of an instance of `CString`. This type can be constructed from a raw +/// C string as well and represents a C string borrowed from another location. +/// +/// Note that this structure is **not** `repr(C)` and is not recommended to be +/// placed in the signatures of FFI functions. Instead safe wrappers of FFI +/// functions may leverage the unsafe [`from_ptr`] constructor to provide a safe +/// interface to other consumers. +/// +/// [`from_ptr`]: #method.from_ptr +/// +/// # Examples +/// +/// Inspecting a foreign C string: +/// +/// ```ignore (extern-declaration) +/// use cstr_core::CStr; +/// use cstr_core::c_char; +/// +/// extern { fn my_string() -> *const c_char; } +/// +/// unsafe { +/// let slice = CStr::from_ptr(my_string()); +/// println!("string length: {}", slice.to_bytes().len()); +/// } +/// ``` +/// +/// Passing a Rust-originating C string: +/// +/// ```ignore (extern-declaration) +/// use cstr_core::{CString, CStr}; +/// use cstr_core::c_char; +/// +/// fn work(data: &CStr) { +/// extern { fn work_with(data: *const c_char); } +/// +/// unsafe { work_with(data.as_ptr()) } +/// } +/// +/// let s = CString::new("data data data data").unwrap(); +/// work(&s); +/// ``` +/// +/// Converting a foreign C string into a Rust [`String`]: +/// +/// [`String`]: ../string/struct.String.html +/// +/// ```ignore (extern-declaration) +/// use cstr_core::CStr; +/// use cstr_core::c_char; +/// +/// extern { fn my_string() -> *const c_char; } +/// +/// fn my_string_safe() -> String { +/// unsafe { +/// CStr::from_ptr(my_string()).to_string_lossy().into_owned() +/// } +/// } +/// +/// println!("string: {}", my_string_safe()); +/// ``` +#[derive(Hash)] +pub struct CStr { + // FIXME: this should not be represented with a DST slice but rather with + // just a raw `c_char` along with some form of marker to make + // this an unsized type. Essentially `sizeof(&CStr)` should be the + // same as `sizeof(&c_char)` but `CStr` should be an unsized type. + inner: [c_char], +} + +/// An error returned from [`CString::new`] to indicate that a nul byte was found +/// in the vector provided. +/// +/// [`CString::new`]: struct.CString.html#method.new +/// +/// # Examples +/// +/// ``` +/// use cstr_core::{CString, NulError}; +/// +/// let _: NulError = CString::new(b"f\0oo".to_vec()).unwrap_err(); +/// ``` +#[cfg(feature = "alloc")] +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct NulError(usize, Vec); + +/// An error returned from [`CStr::from_bytes_with_nul`] to indicate that a nul +/// byte was found too early in the slice provided or one wasn't found at all. +/// +/// [`CStr::from_bytes_with_nul`]: struct.CStr.html#method.from_bytes_with_nul +/// +/// # Examples +/// +/// ``` +/// use cstr_core::{CStr, FromBytesWithNulError}; +/// +/// let _: FromBytesWithNulError = CStr::from_bytes_with_nul(b"f\0oo").unwrap_err(); +/// ``` +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct FromBytesWithNulError { + kind: FromBytesWithNulErrorKind, +} + +#[derive(Clone, PartialEq, Eq, Debug)] +enum FromBytesWithNulErrorKind { + InteriorNul(usize), + NotNulTerminated, +} + +impl FromBytesWithNulError { + fn interior_nul(pos: usize) -> FromBytesWithNulError { + FromBytesWithNulError { + kind: FromBytesWithNulErrorKind::InteriorNul(pos), + } + } + fn not_nul_terminated() -> FromBytesWithNulError { + FromBytesWithNulError { + kind: FromBytesWithNulErrorKind::NotNulTerminated, + } + } +} + +/// An error returned from [`CString::into_string`] to indicate that a UTF-8 error +/// was encountered during the conversion. +/// +/// [`CString::into_string`]: struct.CString.html#method.into_string +#[cfg(feature = "alloc")] +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct IntoStringError { + inner: CString, + error: Utf8Error, +} + +#[cfg(feature = "alloc")] +impl CString { + /// Creates a new C-compatible string from a container of bytes. + /// + /// This method will consume the provided data and use the underlying bytes + /// to construct a new string, ensuring that there is a trailing 0 byte. + /// + /// # Examples + /// + /// ```ignore (extern-declaration) + /// use cstr_core::CString; + /// use cstr_core::c_char; + /// + /// extern { fn puts(s: *const c_char); } + /// + /// let to_print = CString::new("Hello!").unwrap(); + /// unsafe { + /// puts(to_print.as_ptr()); + /// } + /// ``` + /// + /// # Errors + /// + /// This function will return an error if the bytes yielded contain an + /// internal 0 byte. The error returned will contain the bytes as well as + /// the position of the nul byte. + pub fn new>>(t: T) -> Result { + Self::_new(t.into()) + } + + fn _new(bytes: Vec) -> Result { + match memchr::memchr(0, &bytes) { + Some(i) => Err(NulError(i, bytes)), + None => Ok(unsafe { CString::from_vec_unchecked(bytes) }), + } + } + + /// Creates a C-compatible string from a byte vector without checking for + /// interior 0 bytes. + /// + /// This method is equivalent to [`new`] except that no runtime assertion + /// is made that `v` contains no 0 bytes, and it requires an actual + /// byte vector, not anything that can be converted to one with Into. + /// + /// [`new`]: #method.new + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let raw = b"foo".to_vec(); + /// unsafe { + /// let c_string = CString::from_vec_unchecked(raw); + /// } + /// ``` + pub unsafe fn from_vec_unchecked(mut v: Vec) -> CString { + v.reserve_exact(1); + v.push(0); + CString { + inner: v.into_boxed_slice(), + } + } + + /// Retakes ownership of a `CString` that was transferred to C. + /// + /// Additionally, the length of the string will be recalculated from the pointer. + /// + /// # Safety + /// + /// This should only ever be called with a pointer that was earlier + /// obtained by calling [`into_raw`] on a `CString`. Other usage (e.g. trying to take + /// ownership of a string that was allocated by foreign code) is likely to lead + /// to undefined behavior or allocator corruption. + /// + /// [`into_raw`]: #method.into_raw + /// + /// # Examples + /// + /// Create a `CString`, pass ownership to an `extern` function (via raw pointer), then retake + /// ownership with `from_raw`: + /// + /// ```ignore (extern-declaration) + /// use cstr_core::CString; + /// use cstr_core::c_char; + /// + /// extern { + /// fn some_extern_function(s: *mut c_char); + /// } + /// + /// let c_string = CString::new("Hello!").unwrap(); + /// let raw = c_string.into_raw(); + /// unsafe { + /// some_extern_function(raw); + /// let c_string = CString::from_raw(raw); + /// } + /// ``` + pub unsafe fn from_raw(ptr: *mut c_char) -> CString { + let len = strlen(ptr) + 1; // Including the NUL byte + let slice = slice::from_raw_parts_mut(ptr, len as usize); + CString { + inner: Box::from_raw(slice as *mut [c_char] as *mut [u8]), + } + } + + /// Transfers ownership of the string to a C caller. + /// + /// The pointer must be returned to Rust and reconstituted using + /// [`from_raw`] to be properly deallocated. Specifically, one + /// should *not* use the standard C `free` function to deallocate + /// this string. + /// + /// Failure to call [`from_raw`] will lead to a memory leak. + /// + /// [`from_raw`]: #method.from_raw + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let c_string = CString::new("foo").unwrap(); + /// + /// let ptr = c_string.into_raw(); + /// + /// unsafe { + /// assert_eq!(b'f', *ptr as u8); + /// assert_eq!(b'o', *ptr.offset(1) as u8); + /// assert_eq!(b'o', *ptr.offset(2) as u8); + /// assert_eq!(b'\0', *ptr.offset(3) as u8); + /// + /// // retake pointer to free memory + /// let _ = CString::from_raw(ptr); + /// } + /// ``` + #[inline] + pub fn into_raw(self) -> *mut c_char { + Box::into_raw(self.into_inner()) as *mut c_char + } + + /// Converts the `CString` into a [`String`] if it contains valid Unicode data. + /// + /// On failure, ownership of the original `CString` is returned. + /// + /// [`String`]: ../string/struct.String.html + pub fn into_string(self) -> Result { + String::from_utf8(self.into_bytes()).map_err(|e| IntoStringError { + error: e.utf8_error(), + inner: unsafe { CString::from_vec_unchecked(e.into_bytes()) }, + }) + } + + /// Returns the underlying byte buffer. + /// + /// The returned buffer does **not** contain the trailing nul separator and + /// it is guaranteed to not have any interior nul bytes. + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let c_string = CString::new("foo").unwrap(); + /// let bytes = c_string.into_bytes(); + /// assert_eq!(bytes, vec![b'f', b'o', b'o']); + /// ``` + pub fn into_bytes(self) -> Vec { + let mut vec = self.into_inner().into_vec(); + let _nul = vec.pop(); + debug_assert_eq!(_nul, Some(0u8)); + vec + } + + /// Equivalent to the [`into_bytes`] function except that the returned vector + /// includes the trailing nul byte. + /// + /// [`into_bytes`]: #method.into_bytes + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let c_string = CString::new("foo").unwrap(); + /// let bytes = c_string.into_bytes_with_nul(); + /// assert_eq!(bytes, vec![b'f', b'o', b'o', b'\0']); + /// ``` + pub fn into_bytes_with_nul(self) -> Vec { + self.into_inner().into_vec() + } + + /// Returns the contents of this `CString` as a slice of bytes. + /// + /// The returned slice does **not** contain the trailing nul separator and + /// it is guaranteed to not have any interior nul bytes. + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let c_string = CString::new("foo").unwrap(); + /// let bytes = c_string.as_bytes(); + /// assert_eq!(bytes, &[b'f', b'o', b'o']); + /// ``` + #[inline] + pub fn as_bytes(&self) -> &[u8] { + &self.inner[..self.inner.len() - 1] + } + + /// Equivalent to the [`as_bytes`] function except that the returned slice + /// includes the trailing nul byte. + /// + /// [`as_bytes`]: #method.as_bytes + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let c_string = CString::new("foo").unwrap(); + /// let bytes = c_string.as_bytes_with_nul(); + /// assert_eq!(bytes, &[b'f', b'o', b'o', b'\0']); + /// ``` + #[inline] + pub fn as_bytes_with_nul(&self) -> &[u8] { + &self.inner + } + + /// Extracts a [`CStr`] slice containing the entire string. + /// + /// [`CStr`]: struct.CStr.html + /// + /// # Examples + /// + /// ``` + /// use cstr_core::{CString, CStr}; + /// + /// let c_string = CString::new(b"foo".to_vec()).unwrap(); + /// let c_str = c_string.as_c_str(); + /// assert_eq!(c_str, CStr::from_bytes_with_nul(b"foo\0").unwrap()); + /// ``` + #[inline] + pub fn as_c_str(&self) -> &CStr { + &*self + } + + /// Converts this `CString` into a boxed [`CStr`]. + /// + /// [`CStr`]: struct.CStr.html + /// + /// # Examples + /// + /// ``` + /// use cstr_core::{CString, CStr}; + /// + /// let c_string = CString::new(b"foo".to_vec()).unwrap(); + /// let boxed = c_string.into_boxed_c_str(); + /// assert_eq!(&*boxed, CStr::from_bytes_with_nul(b"foo\0").unwrap()); + /// ``` + pub fn into_boxed_c_str(self) -> Box { + unsafe { Box::from_raw(Box::into_raw(self.into_inner()) as *mut CStr) } + } + + // Bypass "move out of struct which implements [`Drop`] trait" restriction. + /// + /// [`Drop`]: ../ops/trait.Drop.html + fn into_inner(self) -> Box<[u8]> { + unsafe { + let result = ptr::read(&self.inner); + mem::forget(self); + result + } + } +} + +// Turns this `CString` into an empty string to prevent +// memory unsafe code from working by accident. Inline +// to prevent LLVM from optimizing it away in debug builds. +#[cfg(feature = "alloc")] +impl Drop for CString { + #[inline] + fn drop(&mut self) { + unsafe { + *self.inner.get_unchecked_mut(0) = 0; + } + } +} + +#[cfg(feature = "alloc")] +impl ops::Deref for CString { + type Target = CStr; + + #[inline] + fn deref(&self) -> &CStr { + unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) } + } +} + +#[cfg(feature = "alloc")] +impl fmt::Debug for CString { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[cfg(feature = "alloc")] +impl From for Vec { + #[inline] + fn from(s: CString) -> Vec { + s.into_bytes() + } +} + +impl fmt::Debug for CStr { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "\"")?; + for byte in self + .to_bytes() + .iter() + .flat_map(|&b| ascii::escape_default(b)) + { + f.write_char(byte as char)?; + } + write!(f, "\"") + } +} + +impl<'a> Default for &'a CStr { + fn default() -> &'a CStr { + const SLICE: &'static [c_char] = &[0]; + unsafe { CStr::from_ptr(SLICE.as_ptr()) } + } +} + +#[cfg(feature = "alloc")] +impl Default for CString { + /// Creates an empty `CString`. + fn default() -> CString { + let a: &CStr = Default::default(); + a.to_owned() + } +} + +#[cfg(feature = "alloc")] +impl Borrow for CString { + #[inline] + fn borrow(&self) -> &CStr { + self + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<&'a CStr> for Box { + fn from(s: &'a CStr) -> Box { + let boxed: Box<[u8]> = Box::from(s.to_bytes_with_nul()); + unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) } + } +} + +#[cfg(feature = "alloc")] +impl From> for CString { + #[inline] + fn from(s: Box) -> CString { + s.into_c_string() + } +} + +#[cfg(feature = "alloc")] +impl From for Box { + #[inline] + fn from(s: CString) -> Box { + s.into_boxed_c_str() + } +} + +#[cfg(feature = "alloc")] +impl From for Arc { + #[inline] + fn from(s: CString) -> Arc { + let arc: Arc<[u8]> = Arc::from(s.into_inner()); + unsafe { Arc::from_raw(Arc::into_raw(arc) as *const CStr) } + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<&'a CStr> for Arc { + #[inline] + fn from(s: &CStr) -> Arc { + let arc: Arc<[u8]> = Arc::from(s.to_bytes_with_nul()); + unsafe { Arc::from_raw(Arc::into_raw(arc) as *const CStr) } + } +} + +#[cfg(feature = "alloc")] +impl From for Rc { + #[inline] + fn from(s: CString) -> Rc { + let rc: Rc<[u8]> = Rc::from(s.into_inner()); + unsafe { Rc::from_raw(Rc::into_raw(rc) as *const CStr) } + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<&'a CStr> for Rc { + #[inline] + fn from(s: &CStr) -> Rc { + let rc: Rc<[u8]> = Rc::from(s.to_bytes_with_nul()); + unsafe { Rc::from_raw(Rc::into_raw(rc) as *const CStr) } + } +} + +#[cfg(feature = "alloc")] +impl Default for Box { + fn default() -> Box { + let boxed: Box<[u8]> = Box::from([0]); + unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) } + } +} + +#[cfg(feature = "alloc")] +impl NulError { + /// Returns the position of the nul byte in the slice that was provided to + /// [`CString::new`]. + /// + /// [`CString::new`]: struct.CString.html#method.new + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let nul_error = CString::new("foo\0bar").unwrap_err(); + /// assert_eq!(nul_error.nul_position(), 3); + /// + /// let nul_error = CString::new("foo bar\0").unwrap_err(); + /// assert_eq!(nul_error.nul_position(), 7); + /// ``` + pub fn nul_position(&self) -> usize { + self.0 + } + + /// Consumes this error, returning the underlying vector of bytes which + /// generated the error in the first place. + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let nul_error = CString::new("foo\0bar").unwrap_err(); + /// assert_eq!(nul_error.into_vec(), b"foo\0bar"); + /// ``` + pub fn into_vec(self) -> Vec { + self.1 + } +} + +#[cfg(feature = "alloc")] +impl fmt::Display for NulError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "nul byte found in provided data at position: {}", self.0) + } +} + +impl fmt::Display for FromBytesWithNulError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self.kind { + FromBytesWithNulErrorKind::InteriorNul(..) => { + f.write_str("data provided contains an interior nul byte")? + } + FromBytesWithNulErrorKind::NotNulTerminated => { + f.write_str("data provided is not nul terminated")? + } + } + if let FromBytesWithNulErrorKind::InteriorNul(pos) = self.kind { + write!(f, " at byte pos {}", pos)?; + } + Ok(()) + } +} + +#[cfg(feature = "alloc")] +impl IntoStringError { + /// Consumes this error, returning original [`CString`] which generated the + /// error. + /// + /// [`CString`]: struct.CString.html + pub fn into_cstring(self) -> CString { + self.inner + } + + /// Access the underlying UTF-8 error that was the cause of this error. + pub fn utf8_error(&self) -> Utf8Error { + self.error + } +} + +#[cfg(feature = "alloc")] +impl fmt::Display for IntoStringError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "C string contained non-utf8 bytes") + } +} + +impl CStr { + /// Casts a raw C string to a safe C string wrapper. + /// + /// This function will cast the provided `ptr` to the `CStr` wrapper which + /// allows inspection and interoperation of non-owned C strings. This method + /// is unsafe for a number of reasons: + /// + /// * There is no guarantee to the validity of `ptr`. + /// * The returned lifetime is not guaranteed to be the actual lifetime of + /// `ptr`. + /// * There is no guarantee that the memory pointed to by `ptr` contains a + /// valid nul terminator byte at the end of the string. + /// * It is not guaranteed that the memory pointed by `ptr` won't change + /// before the `CStr` has been destroyed. + /// + /// > **Note**: This operation is intended to be a 0-cost cast but it is + /// > currently implemented with an up-front calculation of the length of + /// > the string. This is not guaranteed to always be the case. + /// + /// # Examples + /// + /// ```ignore (extern-declaration) + /// # fn main() { + /// use cstr_core::CStr; + /// use cstr_core::c_char; + /// + /// extern { + /// fn my_string() -> *const c_char; + /// } + /// + /// unsafe { + /// let slice = CStr::from_ptr(my_string()); + /// println!("string returned: {}", slice.to_str().unwrap()); + /// } + /// # } + /// ``` + pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr { + let len = strlen(ptr); + let ptr = ptr as *const u8; + CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(ptr, len as usize + 1)) + } + + /// Creates a C string wrapper from a byte slice. + /// + /// This function will cast the provided `bytes` to a `CStr` wrapper after + /// ensuring that it is null terminated and does not contain any interior + /// nul bytes. + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CStr; + /// + /// let cstr = CStr::from_bytes_with_nul(b"hello\0"); + /// assert!(cstr.is_ok()); + /// ``` + /// + /// Creating a `CStr` without a trailing nul byte is an error: + /// + /// ``` + /// use cstr_core::CStr; + /// + /// let c_str = CStr::from_bytes_with_nul(b"hello"); + /// assert!(c_str.is_err()); + /// ``` + /// + /// Creating a `CStr` with an interior nul byte is an error: + /// + /// ``` + /// use cstr_core::CStr; + /// + /// let c_str = CStr::from_bytes_with_nul(b"he\0llo\0"); + /// assert!(c_str.is_err()); + /// ``` + pub fn from_bytes_with_nul(bytes: &[u8]) -> Result<&CStr, FromBytesWithNulError> { + let nul_pos = memchr::memchr(0, bytes); + if let Some(nul_pos) = nul_pos { + if nul_pos + 1 != bytes.len() { + return Err(FromBytesWithNulError::interior_nul(nul_pos)); + } + Ok(unsafe { CStr::from_bytes_with_nul_unchecked(bytes) }) + } else { + Err(FromBytesWithNulError::not_nul_terminated()) + } + } + + /// Unsafely creates a C string wrapper from a byte slice. + /// + /// This function will cast the provided `bytes` to a `CStr` wrapper without + /// performing any sanity checks. The provided slice must be null terminated + /// and not contain any interior nul bytes. + /// + /// # Examples + /// + /// ``` + /// use cstr_core::{CStr, CString}; + /// + /// unsafe { + /// let cstring = CString::new("hello").unwrap(); + /// let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul()); + /// assert_eq!(cstr, &*cstring); + /// } + /// ``` + #[inline] + pub unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr { + &*(bytes as *const [u8] as *const CStr) + } + + /// Returns the inner pointer to this C string. + /// + /// The returned pointer will be valid for as long as `self` is and points + /// to a contiguous region of memory terminated with a 0 byte to represent + /// the end of the string. + /// + /// **WARNING** + /// + /// It is your responsibility to make sure that the underlying memory is not + /// freed too early. For example, the following code will cause undefined + /// behavior when `ptr` is used inside the `unsafe` block: + /// + /// ```no_run + /// use cstr_core::{CString}; + /// + /// let ptr = CString::new("Hello").unwrap().as_ptr(); + /// unsafe { + /// // `ptr` is dangling + /// *ptr; + /// } + /// ``` + /// + /// This happens because the pointer returned by `as_ptr` does not carry any + /// lifetime information and the string is deallocated immediately after + /// the `CString::new("Hello").unwrap().as_ptr()` expression is evaluated. + /// To fix the problem, bind the string to a local variable: + /// + /// ```no_run + /// use cstr_core::{CString}; + /// + /// let hello = CString::new("Hello").unwrap(); + /// let ptr = hello.as_ptr(); + /// unsafe { + /// // `ptr` is valid because `hello` is in scope + /// *ptr; + /// } + /// ``` + #[inline] + pub fn as_ptr(&self) -> *const c_char { + self.inner.as_ptr() + } + + /// Converts this C string to a byte slice. + /// + /// This function will calculate the length of this string (which normally + /// requires a linear amount of work to be done) and then return the + /// resulting slice of `u8` elements. + /// + /// The returned slice will **not** contain the trailing nul that this C + /// string has. + /// + /// > **Note**: This method is currently implemented as a constant-time + /// > cast, but it is planned to alter its definition in the future to + /// > perform the length calculation whenever this method is called. + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CStr; + /// + /// let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap(); + /// assert_eq!(c_str.to_bytes(), b"foo"); + /// ``` + #[inline] + pub fn to_bytes(&self) -> &[u8] { + let bytes = self.to_bytes_with_nul(); + &bytes[..bytes.len() - 1] + } + + /// Converts this C string to a byte slice containing the trailing 0 byte. + /// + /// This function is the equivalent of [`to_bytes`] except that it will retain + /// the trailing nul instead of chopping it off. + /// + /// > **Note**: This method is currently implemented as a 0-cost cast, but + /// > it is planned to alter its definition in the future to perform the + /// > length calculation whenever this method is called. + /// + /// [`to_bytes`]: #method.to_bytes + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CStr; + /// + /// let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap(); + /// assert_eq!(c_str.to_bytes_with_nul(), b"foo\0"); + /// ``` + #[inline] + pub fn to_bytes_with_nul(&self) -> &[u8] { + unsafe { &*(&self.inner as *const [c_char] as *const [u8]) } + } + + /// Yields a [`&str`] slice if the `CStr` contains valid UTF-8. + /// + /// This function will calculate the length of this string and check for + /// UTF-8 validity, and then return the [`&str`] if it's valid. + /// + /// > **Note**: This method is currently implemented to check for validity + /// > after a constant-time cast, but it is planned to alter its definition + /// > in the future to perform the length calculation in addition to the + /// > UTF-8 check whenever this method is called. + /// + /// [`&str`]: ../primitive.str.html + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CStr; + /// + /// let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap(); + /// assert_eq!(c_str.to_str(), Ok("foo")); + /// ``` + pub fn to_str(&self) -> Result<&str, Utf8Error> { + // NB: When CStr is changed to perform the length check in .to_bytes() + // instead of in from_ptr(), it may be worth considering if this should + // be rewritten to do the UTF-8 check inline with the length calculation + // instead of doing it afterwards. + str::from_utf8(self.to_bytes()) + } + + /// Converts a `CStr` into a [`Cow`]`<`[`str`]`>`. + /// + /// This function will calculate the length of this string (which normally + /// requires a linear amount of work to be done) and then return the + /// resulting slice as a [`Cow`]`<`[`str`]`>`, replacing any invalid UTF-8 sequences + /// with `U+FFFD REPLACEMENT CHARACTER`. + /// + /// > **Note**: This method is currently implemented to check for validity + /// > after a constant-time cast, but it is planned to alter its definition + /// > in the future to perform the length calculation in addition to the + /// > UTF-8 check whenever this method is called. + /// + /// [`Cow`]: ../borrow/enum.Cow.html + /// [`str`]: ../primitive.str.html + /// + /// # Examples + /// + /// Calling `to_string_lossy` on a `CStr` containing valid UTF-8: + /// + /// ``` + /// use std::borrow::Cow; + /// use cstr_core::CStr; + /// + /// let c_str = CStr::from_bytes_with_nul(b"Hello World\0").unwrap(); + /// assert_eq!(c_str.to_string_lossy(), Cow::Borrowed("Hello World")); + /// ``` + /// + /// Calling `to_string_lossy` on a `CStr` containing invalid UTF-8: + /// + /// ``` + /// use std::borrow::Cow; + /// use cstr_core::CStr; + /// + /// let c_str = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0").unwrap(); + /// assert_eq!( + /// c_str.to_string_lossy(), + /// Cow::Owned(String::from("Hello �World")) as Cow + /// ); + /// ``` + #[cfg(feature = "alloc")] + pub fn to_string_lossy(&self) -> Cow { + String::from_utf8_lossy(self.to_bytes()) + } + + /// Converts a [`Box`]`` into a [`CString`] without copying or allocating. + /// + /// [`Box`]: ../boxed/struct.Box.html + /// [`CString`]: struct.CString.html + /// + /// # Examples + /// + /// ``` + /// use cstr_core::CString; + /// + /// let c_string = CString::new(b"foo".to_vec()).unwrap(); + /// let boxed = c_string.into_boxed_c_str(); + /// assert_eq!(boxed.into_c_string(), CString::new("foo").unwrap()); + /// ``` + #[cfg(feature = "alloc")] + pub fn into_c_string(self: Box) -> CString { + let raw = Box::into_raw(self) as *mut [u8]; + CString { + inner: unsafe { Box::from_raw(raw) }, + } + } +} + +impl PartialEq for CStr { + fn eq(&self, other: &CStr) -> bool { + self.to_bytes().eq(other.to_bytes()) + } +} +impl Eq for CStr {} +impl PartialOrd for CStr { + fn partial_cmp(&self, other: &CStr) -> Option { + self.to_bytes().partial_cmp(&other.to_bytes()) + } +} +impl Ord for CStr { + fn cmp(&self, other: &CStr) -> Ordering { + self.to_bytes().cmp(&other.to_bytes()) + } +} + +#[cfg(feature = "alloc")] +impl ToOwned for CStr { + type Owned = CString; + + fn to_owned(&self) -> CString { + CString { + inner: self.to_bytes_with_nul().into(), + } + } +} + +#[cfg(feature = "alloc")] +impl<'a> From<&'a CStr> for CString { + fn from(s: &'a CStr) -> CString { + s.to_owned() + } +} + +#[cfg(feature = "alloc")] +impl ops::Index for CString { + type Output = CStr; + + #[inline] + fn index(&self, _index: ops::RangeFull) -> &CStr { + self + } +} + +impl AsRef for CStr { + #[inline] + fn as_ref(&self) -> &CStr { + self + } +} + +#[cfg(feature = "alloc")] +impl AsRef for CString { + #[inline] + fn as_ref(&self) -> &CStr { + self + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::borrow::Cow::{Borrowed, Owned}; + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + #[test] + fn c_to_rust() { + let data = b"123\0"; + let ptr = data.as_ptr() as *const c_char; + unsafe { + assert_eq!(CStr::from_ptr(ptr).to_bytes(), b"123"); + assert_eq!(CStr::from_ptr(ptr).to_bytes_with_nul(), b"123\0"); + } + } + + #[test] + fn simple() { + let s = CString::new("1234").unwrap(); + assert_eq!(s.as_bytes(), b"1234"); + assert_eq!(s.as_bytes_with_nul(), b"1234\0"); + } + + #[test] + fn build_with_zero1() { + assert!(CString::new(&b"\0"[..]).is_err()); + } + #[test] + fn build_with_zero2() { + assert!(CString::new(vec![0]).is_err()); + } + + #[test] + fn build_with_zero3() { + unsafe { + let s = CString::from_vec_unchecked(vec![0]); + assert_eq!(s.as_bytes(), b"\0"); + } + } + + #[test] + fn formatted() { + let s = CString::new(&b"abc\x01\x02\n\xE2\x80\xA6\xFF"[..]).unwrap(); + assert_eq!(format!("{:?}", s), r#""abc\x01\x02\n\xe2\x80\xa6\xff""#); + } + + #[test] + fn borrowed() { + unsafe { + let s = CStr::from_ptr(b"12\0".as_ptr() as *const _); + assert_eq!(s.to_bytes(), b"12"); + assert_eq!(s.to_bytes_with_nul(), b"12\0"); + } + } + + #[test] + fn to_str() { + let data = b"123\xE2\x80\xA6\0"; + let ptr = data.as_ptr() as *const c_char; + unsafe { + assert_eq!(CStr::from_ptr(ptr).to_str(), Ok("123…")); + assert_eq!(CStr::from_ptr(ptr).to_string_lossy(), Borrowed("123…")); + } + let data = b"123\xE2\0"; + let ptr = data.as_ptr() as *const c_char; + unsafe { + assert!(CStr::from_ptr(ptr).to_str().is_err()); + assert_eq!( + CStr::from_ptr(ptr).to_string_lossy(), + Owned::(format!("123\u{FFFD}")) + ); + } + } + + #[test] + fn to_owned() { + let data = b"123\0"; + let ptr = data.as_ptr() as *const c_char; + + let owned = unsafe { CStr::from_ptr(ptr).to_owned() }; + assert_eq!(owned.as_bytes_with_nul(), data); + } + + #[test] + fn equal_hash() { + let data = b"123\xE2\xFA\xA6\0"; + let ptr = data.as_ptr() as *const c_char; + let cstr: &'static CStr = unsafe { CStr::from_ptr(ptr) }; + + let mut s = DefaultHasher::new(); + cstr.hash(&mut s); + let cstr_hash = s.finish(); + let mut s = DefaultHasher::new(); + CString::new(&data[..data.len() - 1]).unwrap().hash(&mut s); + let cstring_hash = s.finish(); + + assert_eq!(cstr_hash, cstring_hash); + } + + #[test] + fn from_bytes_with_nul() { + let data = b"123\0"; + let cstr = CStr::from_bytes_with_nul(data); + assert_eq!(cstr.map(CStr::to_bytes), Ok(&b"123"[..])); + let cstr = CStr::from_bytes_with_nul(data); + assert_eq!(cstr.map(CStr::to_bytes_with_nul), Ok(&b"123\0"[..])); + + unsafe { + let cstr = CStr::from_bytes_with_nul(data); + let cstr_unchecked = CStr::from_bytes_with_nul_unchecked(data); + assert_eq!(cstr, Ok(cstr_unchecked)); + } + } + + #[test] + fn from_bytes_with_nul_unterminated() { + let data = b"123"; + let cstr = CStr::from_bytes_with_nul(data); + assert!(cstr.is_err()); + } + + #[test] + fn from_bytes_with_nul_interior() { + let data = b"1\023\0"; + let cstr = CStr::from_bytes_with_nul(data); + assert!(cstr.is_err()); + } + + #[test] + fn into_boxed() { + let orig: &[u8] = b"Hello, world!\0"; + let cstr = CStr::from_bytes_with_nul(orig).unwrap(); + let boxed: Box = Box::from(cstr); + let cstring = cstr.to_owned().into_boxed_c_str().into_c_string(); + assert_eq!(cstr, &*boxed); + assert_eq!(&*boxed, &*cstring); + assert_eq!(&*cstring, cstr); + } + + #[test] + fn boxed_default() { + let boxed = >::default(); + assert_eq!(boxed.to_bytes_with_nul(), &[0]); + } + + #[test] + fn into_rc() { + let orig: &[u8] = b"Hello, world!\0"; + let cstr = CStr::from_bytes_with_nul(orig).unwrap(); + let rc: Rc = Rc::from(cstr); + let arc: Arc = Arc::from(cstr); + + assert_eq!(&*rc, cstr); + assert_eq!(&*arc, cstr); + + let rc2: Rc = Rc::from(cstr.to_owned()); + let arc2: Arc = Arc::from(cstr.to_owned()); + + assert_eq!(&*rc2, cstr); + assert_eq!(&*arc2, cstr); + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/src/lib.rs new file mode 100644 index 0000000..e8f61fe --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/cstring/src/lib.rs @@ -0,0 +1,24 @@ +#![no_std] +mod cstr_core; +extern crate alloc; +use crate::alloc::borrow::ToOwned; +use alloc::string::String; +use core::convert::TryInto; + +pub fn from_str(s: &str) -> usize { + cstr_core::CString::new(s).unwrap().into_raw() as usize +} + +pub fn try_into_string(start: impl TryInto) -> Result { + if let Ok(pos) = start.try_into() { + let s: &cstr_core::CStr = + unsafe { cstr_core::CStr::from_ptr(pos as *const cstr_core::c_char) }; + if let Ok(s) = s.to_str() { + Ok(s.to_owned()) + } else { + Err("error creating cstring") + } + } else { + Err("could not decypher cstring starting point") + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/html_color/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/html_color/Cargo.toml new file mode 100644 index 0000000..b280e56 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/html_color/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "html_color" +version = "0.0.0" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "A library of web colors" +repository = "https://github.com/richardanaya/js-wasm" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/html_color/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/html_color/src/lib.rs new file mode 100644 index 0000000..6d3ba45 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/html_color/src/lib.rs @@ -0,0 +1,150 @@ +#![no_std] + +pub const ALICEBLUE: &'static str = "aliceblue"; +pub const ANTIQUEWHITE: &'static str = "antiquewhite"; +pub const AQUA: &'static str = "aqua"; +pub const AQUAMARINE: &'static str = "aquamarine"; +pub const AZURE: &'static str = "azure"; +pub const BEIGE: &'static str = "beige"; +pub const BISQUE: &'static str = "bisque"; +pub const BLACK: &'static str = "black"; +pub const BLANCHEDALMOND: &'static str = "blanchedalmond"; +pub const BLUE: &'static str = "blue"; +pub const BLUEVIOLET: &'static str = "blueviolet"; +pub const BROWN: &'static str = "brown"; +pub const BURLYWOOD: &'static str = "burlywood"; +pub const CADETBLUE: &'static str = "cadetblue"; +pub const CHARTREUSE: &'static str = "chartreuse"; +pub const CHOCOLATE: &'static str = "chocolate"; +pub const CORAL: &'static str = "coral"; +pub const CORNFLOWERBLUE: &'static str = "cornflowerblue"; +pub const CORNSILK: &'static str = "cornsilk"; +pub const CRIMSON: &'static str = "crimson"; +pub const CYAN: &'static str = "cyan"; +pub const DARKBLUE: &'static str = "darkblue"; +pub const DARKCYAN: &'static str = "darkcyan"; +pub const DARKGOLDENROD: &'static str = "darkgoldenrod"; +pub const DARKGRAY: &'static str = "darkgray"; +pub const DARKGREEN: &'static str = "darkgreen"; +pub const DARKGREY: &'static str = "darkgrey"; +pub const DARKKHAKI: &'static str = "darkkhaki"; +pub const DARKMAGENTA: &'static str = "darkmagenta"; +pub const DARKOLIVEGREEN: &'static str = "darkolivegreen"; +pub const DARKORANGE: &'static str = "darkorange"; +pub const DARKORCHID: &'static str = "darkorchid"; +pub const DARKRED: &'static str = "darkred"; +pub const DARKSALMON: &'static str = "darksalmon"; +pub const DARKSEAGREEN: &'static str = "darkseagreen"; +pub const DARKSLATEBLUE: &'static str = "darkslateblue"; +pub const DARKSLATEGRAY: &'static str = "darkslategray"; +pub const DARKSLATEGREY: &'static str = "darkslategrey"; +pub const DARKTURQUOISE: &'static str = "darkturquoise"; +pub const DARKVIOLET: &'static str = "darkviolet"; +pub const DEEPPINK: &'static str = "deeppink"; +pub const DEEPSKYBLUE: &'static str = "deepskyblue"; +pub const DIMGRAY: &'static str = "dimgray"; +pub const DIMGREY: &'static str = "dimgrey"; +pub const DODGERBLUE: &'static str = "dodgerblue"; +pub const FIREBRICK: &'static str = "firebrick"; +pub const FLORALWHITE: &'static str = "floralwhite"; +pub const FORESTGREEN: &'static str = "forestgreen"; +pub const FUCHSIA: &'static str = "fuchsia"; +pub const GAINSBORO: &'static str = "gainsboro"; +pub const GHOSTWHITE: &'static str = "ghostwhite"; +pub const GOLDENROD: &'static str = "goldenrod"; +pub const GOLD: &'static str = "gold"; +pub const GRAY: &'static str = "gray"; +pub const GREEN: &'static str = "green"; +pub const GREENYELLOW: &'static str = "greenyellow"; +pub const GREY: &'static str = "grey"; +pub const HONEYDEW: &'static str = "honeydew"; +pub const HOTPINK: &'static str = "hotpink"; +pub const INDIANRED: &'static str = "indianred"; +pub const INDIGO: &'static str = "indigo"; +pub const IVORY: &'static str = "ivory"; +pub const KHAKI: &'static str = "khaki"; +pub const LAVENDERBLUSH: &'static str = "lavenderblush"; +pub const LAVENDER: &'static str = "lavender"; +pub const LAWNGREEN: &'static str = "lawngreen"; +pub const LEMONCHIFFON: &'static str = "lemonchiffon"; +pub const LIGHTBLUE: &'static str = "lightblue"; +pub const LIGHTCORAL: &'static str = "lightcoral"; +pub const LIGHTCYAN: &'static str = "lightcyan"; +pub const LIGHTGOLDENRODYELLOW: &'static str = "lightgoldenrodyellow"; +pub const LIGHTGRAY: &'static str = "lightgray"; +pub const LIGHTGREEN: &'static str = "lightgreen"; +pub const LIGHTGREY: &'static str = "lightgrey"; +pub const LIGHTPINK: &'static str = "lightpink"; +pub const LIGHTSALMON: &'static str = "lightsalmon"; +pub const LIGHTSEAGREEN: &'static str = "lightseagreen"; +pub const LIGHTSKYBLUE: &'static str = "lightskyblue"; +pub const LIGHTSLATEGRAY: &'static str = "lightslategray"; +pub const LIGHTSLATEGREY: &'static str = "lightslategrey"; +pub const LIGHTSTEELBLUE: &'static str = "lightsteelblue"; +pub const LIGHTYELLOW: &'static str = "lightyellow"; +pub const LIME: &'static str = "lime"; +pub const LIMEGREEN: &'static str = "limegreen"; +pub const LINEN: &'static str = "linen"; +pub const MAGENTA: &'static str = "magenta"; +pub const MAROON: &'static str = "maroon"; +pub const MEDIUMAQUAMARINE: &'static str = "mediumaquamarine"; +pub const MEDIUMBLUE: &'static str = "mediumblue"; +pub const MEDIUMORCHID: &'static str = "mediumorchid"; +pub const MEDIUMPURPLE: &'static str = "mediumpurple"; +pub const MEDIUMSEAGREEN: &'static str = "mediumseagreen"; +pub const MEDIUMSLATEBLUE: &'static str = "mediumslateblue"; +pub const MEDIUMSPRINGGREEN: &'static str = "mediumspringgreen"; +pub const MEDIUMTURQUOISE: &'static str = "mediumturquoise"; +pub const MEDIUMVIOLETRED: &'static str = "mediumvioletred"; +pub const MIDNIGHTBLUE: &'static str = "midnightblue"; +pub const MINTCREAM: &'static str = "mintcream"; +pub const MISTYROSE: &'static str = "mistyrose"; +pub const MOCCASIN: &'static str = "moccasin"; +pub const NAVAJOWHITE: &'static str = "navajowhite"; +pub const NAVY: &'static str = "navy"; +pub const OLDLACE: &'static str = "oldlace"; +pub const OLIVE: &'static str = "olive"; +pub const OLIVEDRAB: &'static str = "olivedrab"; +pub const ORANGE: &'static str = "orange"; +pub const ORANGERED: &'static str = "orangered"; +pub const ORCHID: &'static str = "orchid"; +pub const PALEGOLDENROD: &'static str = "palegoldenrod"; +pub const PALEGREEN: &'static str = "palegreen"; +pub const PALETURQUOISE: &'static str = "paleturquoise"; +pub const PALEVIOLETRED: &'static str = "palevioletred"; +pub const PAPAYAWHIP: &'static str = "papayawhip"; +pub const PEACHPUFF: &'static str = "peachpuff"; +pub const PERU: &'static str = "peru"; +pub const PINK: &'static str = "pink"; +pub const PLUM: &'static str = "plum"; +pub const POWDERBLUE: &'static str = "powderblue"; +pub const PURPLE: &'static str = "purple"; +pub const REBECCAPURPLE: &'static str = "rebeccapurple"; +pub const RED: &'static str = "red"; +pub const ROSYBROWN: &'static str = "rosybrown"; +pub const ROYALBLUE: &'static str = "royalblue"; +pub const SADDLEBROWN: &'static str = "saddlebrown"; +pub const SALMON: &'static str = "salmon"; +pub const SANDYBROWN: &'static str = "sandybrown"; +pub const SEAGREEN: &'static str = "seagreen"; +pub const SEASHELL: &'static str = "seashell"; +pub const SIENNA: &'static str = "sienna"; +pub const SILVER: &'static str = "silver"; +pub const SKYBLUE: &'static str = "skyblue"; +pub const SLATEBLUE: &'static str = "slateblue"; +pub const SLATEGRAY: &'static str = "slategray"; +pub const SLATEGREY: &'static str = "slategrey"; +pub const SNOW: &'static str = "snow"; +pub const SPRINGGREEN: &'static str = "springgreen"; +pub const STEELBLUE: &'static str = "steelblue"; +pub const TAN: &'static str = "tan"; +pub const TEAL: &'static str = "teal"; +pub const THISTLE: &'static str = "thistle"; +pub const TOMATO: &'static str = "tomato"; +pub const TURQUOISE: &'static str = "turquoise"; +pub const VIOLET: &'static str = "violet"; +pub const WHEAT: &'static str = "wheat"; +pub const WHITE: &'static str = "white"; +pub const WHITESMOKE: &'static str = "whitesmoke"; +pub const YELLOW: &'static str = "yellow"; +pub const YELLOWGREEN: &'static str = "yellowgreen"; diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/Cargo.toml new file mode 100644 index 0000000..7d17e02 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "js-bindgen" +version = "0.0.6" +authors = ["Richard Anaya"] +edition = "2018" +description = "Generate bindings that call JavaScript from WebAssembly" +license = "MIT OR Apache-2.0" +categories = ["wasm"] +repository = "https://github.com/richardanaya/js-wasm" +readme="README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +tera = "1" +serde = { version = "1.0", features = ["derive"] } +Inflector = "0.11.4" +serde_yaml = "0" +clap="2" diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/README.md new file mode 100644 index 0000000..bff97f3 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/README.md @@ -0,0 +1,162 @@ +# js-bindgen + +

+ +

+ +**The project is very ALPHA right now, but it is generating some very basic bindings for Rust and C right now** + +Generate WebAssembly bindings to JavaSCript via [`js-wasm`](https://wasm.js.org) for various languages: + +* Rust +* C +* AssemblyScript + +``` +cargo install js-bindgen +``` + +# Getting Started + +This project is able to take JavaScript API descriptions in yaml like the one below: + +```yaml +Bindings to web console +---- +- namespace: console + functions: + - name: clear + - name: log + parameters: + - name: msg + parameter_type: string + - name: warn + friendly_name: warning + parameters: + - name: msg + parameter_type: string + - name: error + parameters: + - name: msg + parameter_type: string + - name: time + parameters: + - name: msg + parameter_type: string + - name: timeEnd + parameters: + - name: msg + parameter_type: string + +``` + +And turn them into code. + +# Rust + +``` +js-bindgen --lang rust console.yaml +``` + +```rust +#![no_std] + +pub mod console { + use js::*; + + pub fn clear(){ + let func = js!(r###"function(){ + console.clear(); + }"###); + func.invoke_0(); + } + + pub fn log(msg: &str){ + let a0 = msg.as_ptr() as u32; + let a1 = msg.len() as u32; + let func = js!(r###"function(msgPtr,msgLen){ + console.log(this.readUtf8FromMemory(msgPtr,msgLen)); + }"###); + func.invoke_2(a0, a1); + } + +... +``` + +# C + +``` +js-bindgen --lang c console.yaml +``` + +```C +#include "js-wasm.h" + +void console_clear(){ + static int fn; + char *fn_code = "function(){ console.clear(); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_0(fn); +} + +void console_log(char * msg){ + static int fn; + unsigned int a0 = (unsigned int)msg; + unsigned int a1 = js_strlen(msg); + char *fn_code = "function(msgPtr,msgLen){ console.log(this.readUtf8FromMemory(msgPtr,msgLen)); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_2(fn, a0, a1); +} + +... +``` + +# AssemblyScript + +``` +js-bindgen --lang assemblyscript console.yaml +``` + +```ts +import * as jswasm from "./js-wasm" + +let console_clear_fn:f64 = 0; +export function console_clear() : void { + if( console_clear_fn === 0) { + const code = `function(){ console.clear(); }`; + console_clear_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_0(console_clear_fn); +} + +let console_log_fn:f64 = 0; +export function console_log(msg: string) : void { + const a0: f64 = changetype(msg); + const a1: f64 = msg.length*2; + if( console_log_fn === 0) { + const code = `function(msgPtr,msgLen){ console.log(this.readUtf16FromMemory(msgPtr,msgLen)); }`; + console_log_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + jswasm.js_invoke_function_2(console_log_fn, a0, a1); +} + +... +``` + +# Custom Code + +Sometimes you may want to create a binding to code that doesn't exist and still have the power to generate libraries for many targets + +```yaml +- namespace: unicorn + functions: + makeUnicorns: + code: | + function() { + console.log("🦄🦄🦄") + } +``` diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/main.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/main.rs new file mode 100644 index 0000000..a46ab4e --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/main.rs @@ -0,0 +1,96 @@ +use inflector::Inflector; +use serde::*; +use tera::*; +use clap::{Arg, App }; + +fn main() { + let matches = App::new("js-bindgen") + .version("0.0") + .author("Richard Anaya ") + .about("Creates js-wasm bindings for various languages") + .arg(Arg::with_name("lang") + .short("l") + .long("language") + .help("Sets a custom config file") + .takes_value(true) + .required(true)) + .arg(Arg::with_name("INPUT") + .help("Sets the input file to use") + .required(true) + .index(1)) + .get_matches(); + + + let mut tera = Tera::default(); + tera.add_raw_template("rust/module.rs", include_str!("templates/rust/module.rs")) + .unwrap(); + + tera.add_raw_template("c/header.h", include_str!("templates/c/header.h")) + .unwrap(); + + tera.add_raw_template("assemblyscript/module.ts", include_str!("templates/assemblyscript/module.ts")) + .unwrap(); + + let file = matches.value_of("INPUT").unwrap(); + let text = std::fs::read_to_string(file).unwrap(); + + let mut bindings: Vec = serde_yaml::from_str(&text).unwrap(); + + for n in bindings.iter_mut() { + if let Some(fs) = &mut n.functions { + for f in fs.iter_mut() { + if f.friendly_name.is_none() { + f.friendly_name = Some(f.name.to_snake_case()) + } + if let Some(ps) = &mut f.parameters { + for p in ps.iter_mut() { + if p.friendly_name.is_none() { + p.friendly_name = Some(p.name.to_snake_case()) + } + } + } else { + f.parameters = Some(vec![]); + } + } + } else { + n.functions = Some(vec![]); + } + } + + let mut context = Context::new(); + context.insert("bindings", &bindings); + + if let Some(l) = matches.value_of("lang") { + let r = if l == "rust" { + tera.render("rust/module.rs", &context).unwrap() + } else if l == "assemblyscript" { + tera.render("assemblyscript/module.ts", &context).unwrap() + } else { + tera.render("c/header.h", &context).unwrap() + }; + println!("{}", r); + } +} + +#[derive(Serialize, Deserialize)] +struct JSParameter { + name: String, + friendly_name: Option, + parameter_type: String, +} + +#[derive(Serialize, Deserialize)] +struct JSFunction { + name: String, + friendly_name: Option, + parameters: Option>, + output: Option, + code: Option +} + +#[derive(Serialize, Deserialize)] +struct Binding { + namespace: Option, + class: Option, + functions: Option>, +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/assemblyscript/module.ts b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/assemblyscript/module.ts new file mode 100644 index 0000000..2d2c32a --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/assemblyscript/module.ts @@ -0,0 +1,77 @@ +import * as jswasm from "./js-wasm" + +{%- for binding in bindings %} + +{%- for function in binding.functions %} +let {{binding.namespace}}_{% if function.friendly_name -%} +{{function.friendly_name}} +{%- else -%} +{{function.name}} +{%- endif -%}_fn:f64 = 0; +export function {{binding.namespace}}_{% if function.friendly_name -%} + {{function.friendly_name}} + {%- else -%} + {{function.name}} + {%- endif -%}( + {%- for param in function.parameters -%}{{param.friendly_name}}: {% if param.parameter_type == "string" -%} + string + {%- else -%} + f64 + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}){% if function.output %} : f64{% else %} : void{% endif %} { + {% set_global i = 0 %} + {%- for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + const a{{i}}: f64 = changetype({{param.friendly_name}}); + {% set_global i = i + 1 -%} + const a{{i}}: f64 = {{param.friendly_name}}.length*2; + {% else %} + const a{{i}}: f64 = {{param.friendly_name}}; + {% endif -%} + {% set_global i = i + 1 %} + {%- endfor -%} + if( {{binding.namespace}}_{% if function.friendly_name -%} + {{function.friendly_name}} + {%- else -%} + {{function.name}} + {%- endif -%}_fn === 0) { + const code = `function({% for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + {{param.name}}Ptr,{{param.name}}Len + {%- else -%} + {{param.name}} + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}){ {% if function.output -%}return {% endif %}{% if function.output == "object" %} this.storeObject({% endif %}{{binding.namespace}}.{{function.name}}({% for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + this.readUtf16FromMemory({{param.name}}Ptr,{{param.name}}Len) + {%- elif param.parameter_type == "object" -%}this.getObject({{param.name}}) + {%- else -%}{{param.name}} + {%- endif -%}{%- if not loop.last -%}, {% endif -%}{%- endfor -%}){% if function.output == "object" %}){% endif %}; }`; + {{binding.namespace}}_{% if function.friendly_name -%} + {{function.friendly_name}} + {%- else -%} + {{function.name}} + {%- endif -%}_fn = jswasm.js_register_function(changetype(code),code.length*2, 16); + } + {% if function.output -%}return {% endif %}jswasm.js_invoke_function_{{i}}({{binding.namespace}}_{% if function.friendly_name -%} + {{function.friendly_name}} + {%- else -%} + {{function.name}} + {%- endif -%}_fn{% if function.parameters | length > 0 %}, {% endif %}{% set i = 0 -%} + {%- for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + a{{i}}, {% set i = i + 1 -%} + a{{i}} + {%- else -%} + a{{i}} + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}); +} +{% endfor %} +{%- endfor -%} \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/c/header.h b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/c/header.h new file mode 100644 index 0000000..b6f6123 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/c/header.h @@ -0,0 +1,61 @@ +#include "js-wasm.h" + +{%- for binding in bindings %} +{%- for function in binding.functions %} + +{% if function.output -%}double{% else %}void{% endif %} {{binding.namespace}}_{% if function.friendly_name -%} +{{function.friendly_name}} +{%- else -%} +{{function.name}} +{%- endif -%}( + {%- for param in function.parameters -%} {% if param.parameter_type == "string" -%} + char * + {%- else -%} + double + {%- endif %} {{param.friendly_name}} + {%- if not loop.last -%} + , {% endif %} + {%- endfor -%}){ + static int fn; + {% set_global i = 0 %} + {%- for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + unsigned int a{{i}} = (unsigned int){{param.friendly_name}}; + {% set_global i = i + 1 -%} + unsigned int a{{i}} = js_strlen({{param.friendly_name}}); + {% else %} + double a{{i}} = {{param.friendly_name}}; + {% endif -%} + {% set_global i = i + 1 %} + {%- endfor -%} + char *fn_code = "function({% for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + {{param.name}}Ptr,{{param.name}}Len + {%- else -%} + {{param.name}} + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}){ {% if function.output -%}return {% endif %}{% if function.output == "object" %} this.storeObject({% endif %}{{binding.namespace}}.{{function.name}}({% for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + this.readUtf8FromMemory({{param.name}}Ptr,{{param.name}}Len) + {%- elif param.parameter_type == "object" -%}this.getObject({{param.name}}) + {%- else -%}{{param.name}} + {%- endif -%}{%- if not loop.last -%}, {% endif -%}{%- endfor -%}){% if function.output == "object" %}){% endif %}; }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + {% if function.output -%}return {% endif %}js_invoke_function_{{i}}(fn{% if function.parameters | length > 0 %}, {% endif %}{% set i = 0 -%} + {%- for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + a{{i}}, {% set i = i + 1 -%} + a{{i}} + {%- else -%} + a{{i}} + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}); +} +{%- endfor %} +{%- endfor -%} \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/rust/module.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/rust/module.rs new file mode 100644 index 0000000..b68e99b --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js-bindgen/src/templates/rust/module.rs @@ -0,0 +1,68 @@ +#![no_std] + +use js::*; + +{%- for binding in bindings %} + +{%- for function in binding.functions %} + +pub fn {{binding.namespace}}_{% if function.friendly_name -%} + {{function.friendly_name}} + {%- else -%} + {{function.name}} + {%- endif -%}( + {%- for param in function.parameters -%}{{param.friendly_name}}: {% if param.parameter_type == "string" -%} + &str + {%- else -%} + impl Into + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}){% if function.output %} -> f64{% endif %} { + {% set_global i = 0 %} + {%- for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + let a{{i}} = {{param.friendly_name}}.as_ptr() as u32; + {% set_global i = i + 1 -%} + let a{{i}} = {{param.friendly_name}}.len() as u32; + {% else -%} + let a{{i}} = {{param.friendly_name}}.into(); + {% endif -%} + {% set_global i = i + 1 %} + {%- endfor -%} + let func = js!(r###"function({% for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + {{param.name}}Ptr,{{param.name}}Len + {%- else -%} + {{param.name}} + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}){ + {% if function.output -%}return {% endif %}{% if function.output == "object" %} this.storeObject({% endif %}{{binding.namespace}}.{{function.name}}({% for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + this.readUtf8FromMemory({{param.name}}Ptr,{{param.name}}Len) + {%- elif param.parameter_type == "object" -%} + this.getObject({{param.name}}) + {%- else -%} + {{param.name}} + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}){% if function.output == "object" %}){% endif %}; + }"###); + func.invoke_{{i}}( + {%- set i = 0 -%} + {%- for param in function.parameters -%} + {%- if param.parameter_type == "string" -%} + a{{i}}, {% set i = i + 1 -%} + a{{i}} + {%- else -%} + a{{i}} + {%- endif -%} + {%- if not loop.last -%} + , {% endif -%} + {%- endfor -%}){%- if not function.output -%};{%- endif %} +} +{%- endfor %} +{%- endfor -%} \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/js/Cargo.toml new file mode 100644 index 0000000..18386e1 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "js" +version = "0.4.3" +authors = ["Richard Anaya"] +edition = "2021" +description = "Call JavaScript from WebAssembly" +license = "MIT OR Apache-2.0" +categories = ["wasm", "no-std"] +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" +rust-version="1.62" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +callback= {path="../callback",version="0.5"} +spin = "0.9.4" diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/js/README.md new file mode 100644 index 0000000..19b5efa --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js/README.md @@ -0,0 +1,20 @@ +# js-rs + +A library for creating and invoking JavaScript functions from Rust. + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in 'js' by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/js/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/js/src/lib.rs new file mode 100644 index 0000000..ed259d2 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/js/src/lib.rs @@ -0,0 +1,447 @@ +#![no_std] +#![allow(clippy::too_many_arguments)] +extern crate alloc; +use alloc::string::String; +use alloc::vec::Vec; +pub use callback::*; +use spin::Mutex; + +pub const JS_NULL: f64 = 0.0; +pub const JS_UNDEFINED: f64 = 1.0; +pub const DOM_SELF: f64 = 2.0; +pub const DOM_WINDOW: f64 = 2.0; +pub const DOM_DOCUMENT: f64 = 3.0; +pub const DOM_BODY: f64 = 4.0; + +extern "C" { + fn js_register_function(start: f64, len: f64) -> f64; + fn js_release(obj: f64); + fn js_invoke_function( + fn_handle: f64, + a: f64, + b: f64, + c: f64, + d: f64, + e: f64, + f: f64, + g: f64, + h: f64, + i: f64, + j: f64, + ) -> f64; +} + +#[derive(Copy, Clone)] +pub struct JSFunction { + pub fn_handle: f64, +} + +impl From for JSFunction { + fn from(f: f64) -> Self { + JSFunction { fn_handle: f } + } +} + +impl From<&JSFunction> for f64 { + fn from(f: &JSFunction) -> Self { + f.fn_handle + } +} + +impl JSFunction { + pub fn invoke_0(&self) -> f64 +where { + unsafe { + js_invoke_function( + self.fn_handle, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_1(&self, a: A) -> f64 + where + A: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_2(&self, a: A, b: B) -> f64 + where + A: Into, + B: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_3(&self, a: A, b: B, c: C) -> f64 + where + A: Into, + B: Into, + C: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_4(&self, a: A, b: B, c: C, d: D) -> f64 + where + A: Into, + B: Into, + C: Into, + D: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + d.into(), + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_5(&self, a: A, b: B, c: C, d: D, e: E) -> f64 + where + A: Into, + B: Into, + C: Into, + D: Into, + E: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + d.into(), + e.into(), + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_6(&self, a: A, b: B, c: C, d: D, e: E, f: F) -> f64 + where + A: Into, + B: Into, + C: Into, + D: Into, + E: Into, + F: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + d.into(), + e.into(), + f.into(), + 0.0, + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_7(&self, a: A, b: B, c: C, d: D, e: E, f: F, g: G) -> f64 + where + A: Into, + B: Into, + C: Into, + D: Into, + E: Into, + F: Into, + G: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + d.into(), + e.into(), + f.into(), + g.into(), + 0.0, + 0.0, + 0.0, + ) + } + } + + pub fn invoke_8( + &self, + a: A, + b: B, + c: C, + d: D, + e: E, + f: F, + g: G, + h: H, + ) -> f64 + where + A: Into, + B: Into, + C: Into, + D: Into, + E: Into, + F: Into, + G: Into, + H: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + d.into(), + e.into(), + f.into(), + g.into(), + h.into(), + 0.0, + 0.0, + ) + } + } + + pub fn invoke_9( + &self, + a: A, + b: B, + c: C, + d: D, + e: E, + f: F, + g: G, + h: H, + i: I, + ) -> f64 + where + A: Into, + B: Into, + C: Into, + D: Into, + E: Into, + F: Into, + G: Into, + H: Into, + I: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + d.into(), + e.into(), + f.into(), + g.into(), + h.into(), + i.into(), + 0.0, + ) + } + } + + pub fn invoke_10( + &self, + a: A, + b: B, + c: C, + d: D, + e: E, + f: F, + g: G, + h: H, + i: I, + j: J, + ) -> f64 + where + A: Into, + B: Into, + C: Into, + D: Into, + E: Into, + F: Into, + G: Into, + H: Into, + I: Into, + J: Into, + { + unsafe { + js_invoke_function( + self.fn_handle, + a.into(), + b.into(), + c.into(), + d.into(), + e.into(), + f.into(), + g.into(), + h.into(), + i.into(), + j.into(), + ) + } + } +} + +pub fn register_function(code: &str) -> JSFunction { + let start = code.as_ptr(); + let len = code.len(); + unsafe { + JSFunction { + fn_handle: js_register_function(start as usize as f64, len as f64), + } + } +} + +pub struct JSObject { + pub handle: f64, +} + +impl From<&JSObject> for f64 { + fn from(f: &JSObject) -> Self { + f.handle + } +} + +impl From for JSObject { + fn from(n: f64) -> Self { + JSObject { handle: n } + } +} + +impl Drop for JSObject { + fn drop(&mut self) { + unsafe { + js_release(self.handle); + } + } +} + +static ALLOCATIONS: Mutex>>> = Mutex::new(Vec::new()); + +pub fn extract_string_from_memory(allocation_id: usize) -> String { + let allocations = ALLOCATIONS.lock(); + let allocation = allocations.get(allocation_id).unwrap(); + let vec = allocation.as_ref().unwrap(); + String::from_utf8(vec.clone()).unwrap() +} + +#[no_mangle] +pub fn create_allocation(size: usize) -> usize { + let mut buf = Vec::with_capacity(size as usize); + buf.resize(size, 0); + let mut allocations = ALLOCATIONS.lock(); + let i = allocations.len(); + allocations.push(Some(buf)); + i +} + +#[no_mangle] +pub fn allocation_ptr(allocation_id: i32) -> *const u8 { + let allocations = ALLOCATIONS.lock(); + let allocation = allocations.get(allocation_id as usize).unwrap(); + let vec = allocation.as_ref().unwrap(); + vec.as_ptr() +} + +#[no_mangle] +pub fn allocation_len(allocation_id: i32) -> f64 { + let allocations = ALLOCATIONS.lock(); + let allocation = allocations.get(allocation_id as usize).unwrap(); + let vec = allocation.as_ref().unwrap(); + vec.len() as f64 +} + +pub fn clear_allocation(allocation_id: usize) { + let mut allocations = ALLOCATIONS.lock(); + allocations[allocation_id] = None; +} + +#[macro_export] +macro_rules! js { + ($e:expr) => {{ + static mut FN: Option = None; + unsafe { + if FN.is_none() { + FN = Some(js::register_function($e).fn_handle); + } + JSFunction { + fn_handle: FN.unwrap(), + } + } + }}; +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web/Cargo.toml new file mode 100644 index 0000000..b741403 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "web" +version = "0.1.16" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "A library for interacting with the web browser" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +web_common={path="../../crates/web_common",version="0"} +web-dom={path="../../crates/web_dom",version="0"} +web_console={path="../../crates/web_console",version="0"} +web_random={path="../../crates/web_random",version="0"} +web_timer={path="../../crates/web_timer",version="0"} +web_canvas={path="../../crates/web_canvas",version="0"} +html_color={path="../../crates/html_color",version="0"} +js = {path="../js",version="0"} +class_names= "0" +spin = "0.9.0" +web_local_storage={path="../../crates/web_local_storage",version="0"} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web/README.md new file mode 100644 index 0000000..20dbac2 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web/README.md @@ -0,0 +1,70 @@ +# web-rs + +docs.rs docs + +A Rust library full of useful functions from various microlibraries for interacting with the web browser using [`js-wasm`](../../). + +

+ +

+ +```toml +[dependencies] +web = "0.1" +``` + +```rust +use web::*; + +#[no_mangle] +pub fn main() { + set_interval(|| { + log(&format!("⏰ {}", random())); + }, 1000); +} +``` +```html + + + + + + + ... + + +``` +```make +# cli commands for building web assembly +build: + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/helloworld.wasm . +lint: + @cargo fmt +serve: + python3 -m http.server 8080 +``` + +- [x] console, errors, timing +- [x] timers, render loops, intervals +- [x] random numbers +- [ ] DOM +- [ ] canvas +- [ ] webgl + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `web` by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web/src/lib.rs new file mode 100644 index 0000000..34ed279 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web/src/lib.rs @@ -0,0 +1,12 @@ +#![no_std] +pub use class_names::*; +pub use html_color::*; +pub use js::*; +pub use spin::{Mutex, MutexGuard}; +pub use web_canvas::*; +pub use web_common::*; +pub use web_console::*; +pub use web_dom::*; +pub use web_local_storage::*; +pub use web_random::*; +pub use web_timer::*; diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/Cargo.toml new file mode 100644 index 0000000..ff80705 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "web_canvas" +version = "0.0.7" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "Web functions for canvas 2D" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = {path="../js",version="0"} \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/README.md new file mode 100644 index 0000000..f80a4e3 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/README.md @@ -0,0 +1,20 @@ +# web_console + +docs.rs docs + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in 'web_console' by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/src/lib.rs new file mode 100644 index 0000000..9a57c56 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_canvas/src/lib.rs @@ -0,0 +1,71 @@ +#![no_std] +use js::*; + +pub struct CanvasContext { + pub handle: f64, +} + +pub trait Canvas2dApi { + fn set_fill_color(&self, color: &str); + fn fill_rect(&self, x: impl Into, y: impl Into, w: impl Into, h: impl Into); + fn clear_rect( + &self, + x: impl Into, + y: impl Into, + w: impl Into, + h: impl Into, + ); +} + +impl CanvasContext { + pub fn from_canvas_element(el: impl Into) -> CanvasContext { + CanvasContext { + handle: { + js!(r#"function(el){ + el = this.getObject(el); + let ctx = el.getContext("2d"); + return this.storeObject(ctx); + }"#) + .invoke_1(el.into()) + }, + } + } +} + +impl Canvas2dApi for CanvasContext { + fn set_fill_color(&self, color: &str) { + js!("function(ctx,strPtr,strLen){ + ctx = this.getObject(ctx); + ctx.fillStyle = this.readUtf8FromMemory(strPtr,strLen); + }") + .invoke_3(self.handle, color.as_ptr() as u32, color.len() as u32); + } + + fn fill_rect( + &self, + x: impl Into, + y: impl Into, + w: impl Into, + h: impl Into, + ) { + js!("function(ctx,x,y,w,h){ + ctx = this.getObject(ctx); + ctx.fillRect(x,y,w,h); + }") + .invoke_5(self.handle, x, y, w, h); + } + + fn clear_rect( + &self, + x: impl Into, + y: impl Into, + w: impl Into, + h: impl Into, + ) { + js!("function(ctx,x,y,w,h){ + ctx = this.getObject(ctx); + ctx.clearRect(x,y,w,h); + }") + .invoke_5(self.handle, x, y, w, h); + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/Cargo.toml new file mode 100644 index 0000000..732ac01 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "web_common" +version = "0.4.3" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "Web functions for common operations" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = {path="../js",version="0"} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/README.md new file mode 100644 index 0000000..969d0f7 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/README.md @@ -0,0 +1,20 @@ +# web_common + +docs.rs docs + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `web_common` by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/src/lib.rs new file mode 100644 index 0000000..f874360 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_common/src/lib.rs @@ -0,0 +1,222 @@ +#![no_std] +use js::*; +extern crate alloc; + +pub trait GetProperty { + fn get_property(el: impl Into, name: &str) -> Option + where + Self: Sized; +} + +impl GetProperty for f64 { + fn get_property(el: impl Into, name: &str) -> Option { + let v = el.into(); + if !is_property_number(v, name) { + return None; + } + Some( + js!("function(el,strPtr,strLen){ + el = this.getObject(el); + return el[this.readUtf8FromMemory(strPtr,strLen)]; + }") + .invoke_3(v, name.as_ptr() as u32, name.len() as u32), + ) + } +} + +impl GetProperty for bool { + fn get_property(el: impl Into, name: &str) -> Option { + let v = js!(r#"function(el,strPtr,strLen){ + el = this.getObject(el); + let i = el[this.readUtf8FromMemory(strPtr,strLen)]; + if(typeof i !== "boolean"){ + return -1; + } + return el[this.readUtf8FromMemory(strPtr,strLen)] ? 1 : 0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + if v == -1.0 { + return None; + } else { + Some(v == 1.0) + } + } +} + +impl GetProperty for alloc::string::String { + fn get_property(el: impl Into, name: &str) -> Option { + let attr = js!(r#"function(o,strPtr,strLen){ + o = this.getObject(o); + const a = o[this.readUtf8FromMemory(strPtr,strLen)]; + if(a === null){ + return -1; + } + return this.writeUtf8ToMemory(a); + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + if attr == -1.0 { + return None; + } else { + let allocation_id = attr as usize; + let s = extract_string_from_memory(allocation_id); + clear_allocation(allocation_id); + Some(s) + } + } +} + +impl GetProperty for JSObject { + fn get_property(el: impl Into, name: &str) -> Option { + let o = js!(r#"function(o,strPtr,strLen){ + o = this.getObject(o); + const a = o[this.readUtf8FromMemory(strPtr,strLen)]; + if(a === null){ + return -1; + } + return this.storeObject(a); + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + if o == -1.0 { + return None; + } else { + Some(JSObject::from(o)) + } + } +} + +pub fn get_property(el: impl Into, id: &str) -> Option +where + T: GetProperty, +{ + T::get_property(el, id) +} + +pub trait SetProperty { + fn set_property(el: impl Into, id: &str, s: Self); +} + +impl SetProperty for f64 { + fn set_property(el: impl Into, id: &str, v: Self) { + js!("function(el,strPtr,strLen,value){ + el = this.getObject(el); + return el[this.readUtf8FromMemory(strPtr,strLen)] = value; + }") + .invoke_4(el.into(), id.as_ptr() as u32, id.len() as u32, v); + } +} + +impl SetProperty for &str { + fn set_property(el: impl Into, name: &str, txt: Self) { + js!(r#"function(o,strPtr,strLen,valPtr,valLen){ + o = this.getObject(o); + o[this.readUtf8FromMemory(strPtr,strLen)] = this.readUtf8FromMemory(valPtr,valLen); + }"#) + .invoke_5( + el.into(), + name.as_ptr() as u32, + name.len() as u32, + txt.as_ptr() as u32, + txt.len() as u32, + ); + } +} + +impl SetProperty for bool { + fn set_property(el: impl Into, name: &str, value: Self) { + js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + o[this.readUtf8FromMemory(strPtr,strLen)] = val > 0; + }"#) + .invoke_4( + el.into(), + name.as_ptr() as u32, + name.len() as u32, + if value { 1.0 } else { 0.0 }, + ); + } +} + +impl SetProperty for JSObject { + fn set_property(el: impl Into, name: &str, value: Self) { + js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + o[this.readUtf8FromMemory(strPtr,strLen)] = this.getObject(val); + }"#) + .invoke_4( + el.into(), + name.as_ptr() as u32, + name.len() as u32, + value.handle, + ); + } +} + +pub fn set_property(el: impl Into, id: &str, v: T) +where + T: SetProperty, +{ + T::set_property(el, id, v) +} + +pub fn is_property_null(el: impl Into, name: &str) -> bool { + let v = js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + return o[this.readUtf8FromMemory(strPtr,strLen)] === null ? 1.0 : 0.0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + v == 1.0 +} + +pub fn is_property_undefined(el: impl Into, name: &str) -> bool { + let v = js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + return o[this.readUtf8FromMemory(strPtr,strLen)] === undefined ? 1.0 : 0.0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + v == 1.0 +} + +pub fn is_property_number(el: impl Into, name: &str) -> bool { + let v = js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + return typeof o[this.readUtf8FromMemory(strPtr,strLen)] === "number" ? 1.0 : 0.0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + v == 1.0 +} + +pub fn is_property_bool(el: impl Into, name: &str) -> bool { + let v = js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + return typeof o[this.readUtf8FromMemory(strPtr,strLen)] === "boolean" ? 1.0 : 0.0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + v == 1.0 +} + +pub fn is_property_string(el: impl Into, name: &str) -> bool { + let v = js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + return typeof o[this.readUtf8FromMemory(strPtr,strLen)] === "string" ? 1.0 : 0.0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + v == 1.0 +} + +pub fn is_property_object(el: impl Into, name: &str) -> bool { + let v = js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + return typeof o[this.readUtf8FromMemory(strPtr,strLen)] === "object" ? 1.0 : 0.0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + v == 1.0 +} + +pub fn is_property_array(el: impl Into, name: &str) -> bool { + let v = js!(r#"function(o,strPtr,strLen,val){ + o = this.getObject(o); + return Array.isArray(o[this.readUtf8FromMemory(strPtr,strLen)]) ? 1.0 : 0.0; + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + v == 1.0 +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/Cargo.toml new file mode 100644 index 0000000..8ead089 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "web_console" +version = "0.3.7" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "Web functions for console" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = {path="../js",version="0"} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/README.md new file mode 100644 index 0000000..f80a4e3 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/README.md @@ -0,0 +1,20 @@ +# web_console + +docs.rs docs + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in 'web_console' by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/src/lib.rs new file mode 100644 index 0000000..dfab465 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_console/src/lib.rs @@ -0,0 +1,55 @@ +#![no_std] + +use js::*; + +pub fn console_clear() { + let func = js!(r###"function(){ + console.clear(); + }"###); + func.invoke_0(); +} + +pub fn console_log(msg: &str) { + let a0 = msg.as_ptr() as u32; + let a1 = msg.len() as u32; + let func = js!(r###"function(msgPtr,msgLen){ + console.log(this.readUtf8FromMemory(msgPtr,msgLen)); + }"###); + func.invoke_2(a0, a1); +} + +pub fn console_warning(msg: &str) { + let a0 = msg.as_ptr() as u32; + let a1 = msg.len() as u32; + let func = js!(r###"function(msgPtr,msgLen){ + console.warn(this.readUtf8FromMemory(msgPtr,msgLen)); + }"###); + func.invoke_2(a0, a1); +} + +pub fn console_error(msg: &str) { + let a0 = msg.as_ptr() as u32; + let a1 = msg.len() as u32; + let func = js!(r###"function(msgPtr,msgLen){ + console.error(this.readUtf8FromMemory(msgPtr,msgLen)); + }"###); + func.invoke_2(a0, a1); +} + +pub fn console_time(msg: &str) { + let a0 = msg.as_ptr() as u32; + let a1 = msg.len() as u32; + let func = js!(r###"function(msgPtr,msgLen){ + console.time(this.readUtf8FromMemory(msgPtr,msgLen)); + }"###); + func.invoke_2(a0, a1); +} + +pub fn console_time_end(msg: &str) { + let a0 = msg.as_ptr() as u32; + let a1 = msg.len() as u32; + let func = js!(r###"function(msgPtr,msgLen){ + console.timeEnd(this.readUtf8FromMemory(msgPtr,msgLen)); + }"###); + func.invoke_2(a0, a1); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/Cargo.toml new file mode 100644 index 0000000..219f885 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "web-dom" +version = "0.3.10" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "Web functions for DOM manipulation" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = {path="../js",version="0"} +web_common = {path="../web_common", version="0"} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/README.md new file mode 100644 index 0000000..1286527 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/README.md @@ -0,0 +1,20 @@ +# web_dom + +docs.rs docs + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `web_dom` by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/src/lib.rs new file mode 100644 index 0000000..3c5355d --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_dom/src/lib.rs @@ -0,0 +1,221 @@ +#![no_std] +use js::*; +extern crate alloc; +use alloc::boxed::Box; +use alloc::string::String; +use web_common::*; + +pub fn get_element_by_id(id: &str) -> JSObject { + js!("function(strPtr,strLen){ + const el = document.getElementById(this.readUtf8FromMemory(strPtr,strLen)); + return this.storeObject(el); + }") + .invoke_2(id.as_ptr() as u32, id.len() as u32) + .into() +} + +pub fn query_selector(id: &str) -> JSObject { + js!("function(strPtr,strLen){ + const selector = document.querySelector(this.readUtf8FromMemory(strPtr,strLen)); + return this.storeObject(selector); + }") + .invoke_2(id.as_ptr() as u32, id.len() as u32) + .into() +} + +pub fn set_style(dom: impl Into, name: &str, value: &str) { + js!("function(el,strPtr,strLen,valPtr,valLen){ + el = this.getObject(el); + const name = this.readUtf8FromMemory(strPtr,strLen); + const value = this.readUtf8FromMemory(valPtr,valLen); + el.style[name] = value; + }") + .invoke_5( + dom.into(), + name.as_ptr() as u32, + name.len() as u32, + value.as_ptr() as u32, + value.len() as u32, + ); +} + +pub fn add_event_listener( + dom: impl Into, + event: &str, + handler: impl FnMut(f64) + Send + 'static, +) { + let cb = create_callback_1(handler); + js!("function(el,strPtr,strLen,callback){ + el = this.getObject(el); + const event = this.readUtf8FromMemory(strPtr,strLen); + el.addEventListener(event,this.createCallback(callback)); + }") + .invoke_4(dom.into(), event.as_ptr() as u32, event.len() as u32, cb); +} + +pub struct KeyDownEvent { + pub handle: JSObject, +} + +impl KeyDownEvent { + pub fn from_event(ev: impl Into) -> KeyDownEvent { + KeyDownEvent { handle: ev.into() } + } + + pub fn key_code(&self) -> u32 { + js!("function(ev){ + ev = this.getObject(ev); + return ev.keyCode; + }") + .invoke_1(&self.handle) as u32 + } +} + +pub fn attach_shadow(el: impl Into, open: bool) -> JSObject { + js!(r#"function(el,open){ + el = this.getObject(el); + el.attachShadow({mode:open?"open":"closed"}); + return this.storeObject(el.shadowRoot); + }"#) + .invoke_2(el.into(), if open { 1.0 } else { 0.0 }) + .into() +} + +pub fn set_inner_html(el: impl Into, html: &str) { + js!(r#"function(el,strPtr,strLen){ + el = this.getObject(el); + el.innerHTML = this.readUtf8FromMemory(strPtr,strLen); + }"#) + .invoke_3(el.into(), html.as_ptr() as u32, html.len() as u32); +} + +pub fn get_attribute(el: impl Into, name: &str) -> Option { + let attr = js!(r#"function(el,strPtr,strLen){ + el = this.getObject(el); + const a = el.getAttribute(this.readUtf8FromMemory(strPtr,strLen)); + if(a === null){ + return -1; + } + return this.writeUtf8ToMemory(a); + }"#) + .invoke_3(el.into(), name.as_ptr() as u32, name.len() as u32); + if attr == -1.0 { + None + } else { + let allocation_id = attr as usize; + let s = extract_string_from_memory(allocation_id); + clear_allocation(allocation_id); + Some(s) + } +} + +pub struct KeyEventHandler { + pub handler: Option>, +} + +impl KeyEventHandler { + pub fn new(f: impl Sync + FnMut(KeyEvent) + 'static + Send) -> KeyEventHandler { + KeyEventHandler { + handler: Some(Box::new(f)), + } + } +} + +pub struct KeyEvent { + obj: JSObject, +} + +impl KeyEvent { + pub fn new(o: f64) -> KeyEvent { + KeyEvent { + obj: JSObject::from(o), + } + } + + pub fn key_code(&self) -> usize { + let key_code: f64 = get_property(self.obj.handle, "keyCode").unwrap(); + key_code as usize + } + + pub fn target(&self) -> JSObject { + get_property(self.obj.handle, "target").unwrap() + } +} + +pub struct InputElement { + obj: JSObject, +} + +impl InputElement { + pub fn new(o: f64) -> InputElement { + InputElement { + obj: JSObject::from(o), + } + } + + pub fn from(o: JSObject) -> InputElement { + InputElement { obj: o } + } + + pub fn value(&self) -> Option { + get_property(&self.obj, "value") + } + + pub fn set_value(&mut self, s: &str) { + set_property(&self.obj, "value", s) + } +} + +pub struct MouseEventHandler { + pub handler: Option>, +} + +impl MouseEventHandler { + pub fn new(f: impl Sync + FnMut(MouseEvent) + 'static + Send) -> MouseEventHandler { + MouseEventHandler { + handler: Some(Box::new(f)), + } + } +} + +pub struct MouseEvent { + obj: JSObject, +} + +impl MouseEvent { + pub fn new(o: f64) -> MouseEvent { + MouseEvent { + obj: JSObject::from(o), + } + } + pub fn target(&self) -> JSObject { + get_property(self.obj.handle, "target").unwrap() + } +} + +pub struct EventHandler { + pub handler: Option>, +} + +impl EventHandler { + pub fn new(f: impl Sync + FnMut(Event) + 'static + Send) -> EventHandler { + EventHandler { + handler: Some(Box::new(f)), + } + } +} + +pub struct Event { + obj: JSObject, +} + +impl Event { + pub fn new(o: f64) -> Event { + Event { + obj: JSObject::from(o), + } + } + pub fn target(&self) -> JSObject { + get_property(self.obj.handle, "target").unwrap() + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/Cargo.toml new file mode 100644 index 0000000..b32ba53 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "web_local_storage" +version = "0.0.3" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "Web functions for local storage" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = {path="../js",version="0"} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/README.md new file mode 100644 index 0000000..77b4a07 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/README.md @@ -0,0 +1,20 @@ +# web_console + +docs.rs docs + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in 'web_local_storage' by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/src/lib.rs new file mode 100644 index 0000000..403f0db --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_local_storage/src/lib.rs @@ -0,0 +1,53 @@ +#![no_std] +extern crate alloc; +use alloc::string::String; + +use js::*; + +pub fn local_storage_set_item(id: &str, data: &str) { + let a0 = id.as_ptr() as u32; + let a1 = id.len() as u32; + let d0 = data.as_ptr() as u32; + let d1 = data.len() as u32; + let func = js!(r###"function(idPtr,idLen,dataPtr,dataLen){ + window.localStorage.setItem(this.readUtf8FromMemory(idPtr,idLen),this.readUtf8FromMemory(dataPtr,dataLen)); + }"###); + func.invoke_4(a0, a1, d0, d1); +} + +pub fn local_storage_get_item(id: &str) -> Option { + let a0 = id.as_ptr() as u32; + let a1 = id.len() as u32; + let func = js!(r###"function(idPtr,idLen){ + const a = window.localStorage.getItem(this.readUtf8FromMemory(idPtr,idLen)); + if(a === null){ + return -1; + } + return this.writeUtf8ToMemory(a); + }"###); + let txt = func.invoke_2(a0, a1); + if txt == -1.0 { + return None; + } else { + let allocation_id = txt as usize; + let s = extract_string_from_memory(allocation_id); + clear_allocation(allocation_id); + Some(s) + } +} + +pub fn local_storage_remove_item(id: &str) { + let a0 = id.as_ptr() as u32; + let a1 = id.len() as u32; + let func = js!(r###"function(idPtr,idLen){ + window.localStorage.removeItem(this.readUtf8FromMemory(idPtr,idLen)); + }"###); + func.invoke_2(a0, a1); +} + +pub fn local_storage_clear() { + let func = js!(r###"function(idPtr,idLen,dataPtr,dataLen){ + window.localStorage.clear(); + }"###); + func.invoke_0(); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/Cargo.toml new file mode 100644 index 0000000..94621da --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "web_random" +version = "0.1.5" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "Web functions for randomness" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = {path="../js",version="0"} \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/README.md new file mode 100644 index 0000000..2df8643 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/README.md @@ -0,0 +1,20 @@ +# web_random + +docs.rs docs + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in 'web_random' by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/src/lib.rs new file mode 100644 index 0000000..255e415 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_random/src/lib.rs @@ -0,0 +1,9 @@ +#![no_std] +use js::*; + +pub fn random() -> f64 { + js!("function(){ + return Math.random(); + }") + .invoke_0() +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/Cargo.toml new file mode 100644 index 0000000..c0531a1 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "web_timer" +version = "0.2.5" +authors = ["Richard Anaya"] +edition = "2018" +license = "MIT OR Apache-2.0" +description = "Web functions for timers" +repository = "https://github.com/richardanaya/js-wasm" +readme = "README.md" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = {path="../js",version="0"} \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/README.md new file mode 100644 index 0000000..188c191 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/README.md @@ -0,0 +1,20 @@ +# web_timer + +docs.rs docs + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in 'web_timer' by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/src/lib.rs new file mode 100644 index 0000000..f894157 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/web_timer/src/lib.rs @@ -0,0 +1,79 @@ +#![no_std] +use core::future::Future; +use js::*; + +pub type Handle = f64; + +pub fn set_timeout( + callback: impl FnMut() -> () + Send + 'static, + milliseconds: impl Into, +) -> (Handle, JSFunction) { + let cb = create_callback_0(callback); + let handle = js!("function(handler,time){ + window.setTimeout(this.createCallback(handler),time); + }") + .invoke_2(cb, milliseconds); + (handle, cb.into()) +} + +pub fn sleep(milliseconds: impl Into) -> impl Future { + let (future, cb) = create_callback_future_0(); + js!("function(handler,time){ + window.setTimeout(this.createCallback(handler),time); + }") + .invoke_2(cb, milliseconds); + future +} + +pub fn set_interval( + callback: impl FnMut() -> () + Send + 'static, + milliseconds: impl Into, +) -> (Handle, JSFunction) { + let cb = create_callback_0(callback); + let handle = js!("function(handler,time){ + window.setInterval(this.createCallback(handler),time); + }") + .invoke_2(cb, milliseconds); + (handle, cb.into()) +} + +pub fn request_animation_frame(callback: impl FnMut() -> () + Send + 'static) -> JSFunction { + let cb = create_callback_0(callback); + js!("function(handler){ + window.requestAnimationFrame(this.createCallback(handler)); + }") + .invoke_1(cb); + cb.into() +} + +pub fn request_animation_loop(callback: impl FnMut(f64) -> () + Send + 'static) -> JSFunction { + let cb = create_callback_1(callback); + js!("function(cb){ + cb = this.createCallback(cb); + let time = Date.now(); + function run(){ + let new_time = Date.now(); + let delta = new_time-time; + time = new_time; + window.requestAnimationFrame(run); + cb(delta); + } + window.requestAnimationFrame(run); + }") + .invoke_1(cb); + cb.into() +} + +pub fn clear_timeout(handle: Handle) { + js!("function(handle){ + window.clearTimeout(handle); + }") + .invoke_1(handle); +} + +pub fn clear_interval(handle: Handle) { + js!("function(handle){ + window.clearInterval(handle); + }") + .invoke_1(handle); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/Cargo.toml new file mode 100644 index 0000000..79e3df2 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "webcomponent" +version = "0.6.2" +edition = "2018" +authors = ["Richard Anaya"] +categories = ["wasm", "no-std", "web"] +include = [ + "src/**/*.rs", + "Cargo.toml", +] +license = "MIT OR Apache-2.0" +homepage = "https://github.com/richardanaya/webcomponent" +repository = "https://github.com/richardanaya/webcomponent" +description = "A library for creating web components" + +[dependencies] +js = {path="../js",version="0"} +callback= {path="../callback",version="0.5.0"} +spin = "0.7.0" + +[dependencies.lazy_static] +version = "1" +default-features = false +features = ["spin_no_std"] diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/README.md b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/README.md new file mode 100644 index 0000000..466db03 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/README.md @@ -0,0 +1,168 @@ +# webcomponent + +docs.rs docs + +[Web components](https://www.webcomponents.org/) are a W3C standard for writing your own HTML element. `webcomponent` is a Rust library for easily writing your own web components in Rust with [`js_ffi`](https://github.com/richardanaya/js_ffi). + +Features: +- [x] Shadow DOM +- [x] Observable attributes +- [x] Helper functions +- [x] `#![no_std]` and `alloc` + +# Hello World +```toml +[lib] +crate-type =["cdylib"] # configures rust project to build a web assembly module + +[dependencies] +webcomponent="0.5" # for registering our web component +``` +```rust +use webcomponent::*; + +struct HelloWorld { + element: HTMLElement +} + +impl CustomElement for HelloWorld { + fn new(element:HTMLElement) -> Self { + HelloWorld(element) + } + fn connected(&mut self){ + set_html(&self.element,"Hello World!"); + } +} + +#[no_mangle] +fn main() { + HelloWorld::register("hello-world"); +} +``` +```html + + + + + + + + +``` +```makefile +# cli commands for building web assembly I find useful +build: + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/helloworld.wasm . +lint: + @cargo fmt +serve: + python3 -m http.server 8080 +``` + + +See demo [here](https://richardanaya.github.io/webcomponent/examples/helloworld/) + +# Shadow DOM + +```rust +struct HelloWorld { + element:HTMLElement +} + +impl CustomElement for HelloWorld { + fn new(element: HTMLElement) -> Self { + HelloWorld(element) + } + fn connected(&mut self) { + let shadow_dom = attach_shadow(&self.element, true); + set_html(&shadow_dom, r#"
Hello !
"#); + set_html(&self.element, r#"Richard"#); + } +} +``` + +See demo [here](https://richardanaya.github.io/webcomponent/examples/shadowdom/) + +# Observable Attributes + +```rust +struct HelloPerson { + element: HTMLElement +} + +impl CustomElement for HelloPerson { + fn new(element: HTMLElement) -> Self { + HelloPerson(element) + } + + fn observed_attributes() -> Vec<&'static str> { + vec!["first_name"] + } + + fn connected(&mut self) { + self.render(); + } + + fn attribute_changed(&mut self, _name: String, _old_value: Option, _new_value: Option) { + self.render(); + } +} + +impl HelloPerson { + fn render(&mut self){ + let first_name = get_attribute(&self.element, "first_name").unwrap_or("human".to_string()); + let msg = "Hello ".to_string() + &first_name; + set_html(&self.element, &msg); + } +} +``` + +See demo [here](https://richardanaya.github.io/webcomponent/examples/observable_attributes/) + +# What about the rest of Javscript? + +With `webcomponent` you have a handle to an html element, this is simply a reference to your component that exists in the DOM. With it we can use [`js_ffi`](https://github.com/richardanaya/js_ffi) ( or any [`js_ffi` based library](https://github.com/richardanaya/js_ffi#standard-web-libraries) ) to do whatever we want to do. + +```rust +use webcomponent::*; +use js_ffi::*; + +struct LoudButton { + element: HTMLElement +} + +impl CustomElement for LoudButton { + fn new(element:HTMLElement) -> Self { + LoudButton(element) + } + fn connected(&mut self){ + set_html(&self.element,r#""#); + js!(Node.prototype.addEventListener).call_2( + &self.element, + "click", + create_callback_0(|| { + js!(window.alert).invoke_1("I was clicked!"); + }), + ); + } +} +``` + +# License + +This project is licensed under either of + + * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license ([LICENSE-MIT](LICENSE-MIT) or + http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in `webcomponent` by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. + diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/Cargo.toml new file mode 100644 index 0000000..ec0f3c2 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "example" +version = "0.1.0" +authors = ["richard "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +web = {path="../../../web"} + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/Makefile b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/Makefile new file mode 100644 index 0000000..148ef8a --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/Makefile @@ -0,0 +1,7 @@ +build: + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/example.wasm . +lint: + @cargo fmt +serve: + python3 -m http.server 8089 \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/example.wasm b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/example.wasm new file mode 100755 index 0000000..970bc8a Binary files /dev/null and b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/example.wasm differ diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/index.html b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/index.html new file mode 100644 index 0000000..5cb8904 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/index.html @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/src/lib.rs new file mode 100644 index 0000000..83a35fc --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/helloworld/src/lib.rs @@ -0,0 +1,17 @@ +use web::*; + +struct HelloWorld(HTMLElement); + +impl CustomElement for HelloWorld { + fn new(element: HTMLElement) -> Self { + HelloWorld(element) + } + fn connected(&mut self) { + set_inner_html(self.0, "Hello World!"); + } +} + +#[no_mangle] +fn main() { + HelloWorld::register("hello-world"); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/Cargo.toml new file mode 100644 index 0000000..93f39b1 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "example" +version = "0.1.0" +authors = ["richard "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +webcomponent = {path="../../"} +js_ffi = "0.6" + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/Makefile b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/Makefile new file mode 100644 index 0000000..148ef8a --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/Makefile @@ -0,0 +1,7 @@ +build: + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/example.wasm . +lint: + @cargo fmt +serve: + python3 -m http.server 8089 \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/example.wasm b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/example.wasm new file mode 100755 index 0000000..b565d47 Binary files /dev/null and b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/example.wasm differ diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/index.html b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/index.html new file mode 100644 index 0000000..e3341a4 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/index.html @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/src/lib.rs new file mode 100644 index 0000000..e95db09 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/loudbutton/src/lib.rs @@ -0,0 +1,27 @@ +use js_ffi::*; +use webcomponent::*; + +struct LoudButton { + element: HTMLElement, +} + +impl CustomElement for LoudButton { + fn new(element: HTMLElement) -> Self { + LoudButton { element } + } + fn connected(&mut self) { + set_html(&self.element, ""); + js!(Node.prototype.addEventListener).call_2( + &self.element, + "click", + create_callback_0(|| { + js!(window.alert).invoke_1("I was clicked!"); + }), + ); + } +} + +#[no_mangle] +fn main() { + LoudButton::register("loud-button"); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/Cargo.toml new file mode 100644 index 0000000..93f39b1 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "example" +version = "0.1.0" +authors = ["richard "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +webcomponent = {path="../../"} +js_ffi = "0.6" + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/Makefile b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/Makefile new file mode 100644 index 0000000..148ef8a --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/Makefile @@ -0,0 +1,7 @@ +build: + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/example.wasm . +lint: + @cargo fmt +serve: + python3 -m http.server 8089 \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/example.wasm b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/example.wasm new file mode 100755 index 0000000..f0b48e2 Binary files /dev/null and b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/example.wasm differ diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/index.html b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/index.html new file mode 100644 index 0000000..80467ee --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/index.html @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/src/lib.rs new file mode 100644 index 0000000..ca4e55a --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/observable_attributes/src/lib.rs @@ -0,0 +1,39 @@ +use webcomponent::*; + +struct HelloPerson(HTMLElement); + +impl CustomElement for HelloPerson { + fn new(element: HTMLElement) -> Self { + HelloPerson(element) + } + + fn observed_attributes() -> Vec<&'static str> { + vec!["first_name"] + } + + fn connected(&mut self) { + self.render(); + } + + fn attribute_changed( + &mut self, + _name: String, + _old_value: Option, + _new_value: Option, + ) { + self.render(); + } +} + +impl HelloPerson { + fn render(&mut self) { + let first_name = get_attribute(&self.0, "first_name").unwrap_or("human".to_string()); + let msg = "Hello ".to_string() + &first_name; + set_html(&self.0, &msg); + } +} + +#[no_mangle] +fn main() { + HelloPerson::register("hello-person"); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/Cargo.toml new file mode 100644 index 0000000..93f39b1 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "example" +version = "0.1.0" +authors = ["richard "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +webcomponent = {path="../../"} +js_ffi = "0.6" + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/Makefile b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/Makefile new file mode 100644 index 0000000..148ef8a --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/Makefile @@ -0,0 +1,7 @@ +build: + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/example.wasm . +lint: + @cargo fmt +serve: + python3 -m http.server 8089 \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/example.wasm b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/example.wasm new file mode 100755 index 0000000..027272f Binary files /dev/null and b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/example.wasm differ diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/index.html b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/index.html new file mode 100644 index 0000000..5cb8904 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/index.html @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/src/lib.rs new file mode 100644 index 0000000..5d2510c --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/shadowdom/src/lib.rs @@ -0,0 +1,19 @@ +use webcomponent::*; + +struct HelloWorld(HTMLElement); + +impl CustomElement for HelloWorld { + fn new(element: HTMLElement) -> Self { + HelloWorld(element) + } + fn connected(&mut self) { + let shadow_dom = attach_shadow(&self.0, true); + set_html(&shadow_dom, r#"
Hello !
"#); + set_html(&self.0, r#"Richard"#); + } +} + +#[no_mangle] +fn main() { + HelloWorld::register("hello-world"); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/Cargo.toml new file mode 100644 index 0000000..9ed56c5 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "example" +version = "0.1.0" +authors = ["richard "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +webcomponent = {path="../../"} +js_ffi = "0.6" +web_console = "0" +web-dom = "0" +globals = "1" + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/Makefile b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/Makefile new file mode 100644 index 0000000..148ef8a --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/Makefile @@ -0,0 +1,7 @@ +build: + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/example.wasm . +lint: + @cargo fmt +serve: + python3 -m http.server 8089 \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/example.wasm b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/example.wasm new file mode 100755 index 0000000..13dce47 Binary files /dev/null and b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/example.wasm differ diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/index.html b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/index.html new file mode 100644 index 0000000..0c509e0 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/index.html @@ -0,0 +1,22 @@ + + + +Todo + + + + + + + + + +
+ + Write Rust + Read that book + Hang picture + +
+ + \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/lib.rs new file mode 100644 index 0000000..302f5b0 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/lib.rs @@ -0,0 +1,118 @@ +use js_ffi::*; +use web_console::*; +use web_dom::*; +use webcomponent::*; + +struct TodoList { + items: Vec, +} + +impl Default for TodoList { + fn default() -> Self { + TodoList { + items: vec![TodoItem { + done: true, + description: "write some rust".to_string(), + }], + } + } +} + +struct TodoItem { + done: bool, + description: String, +} + +struct TodoListComponent { + element: HTMLElement, + shadow_root: HTMLElement, +} + +impl CustomElement for TodoListComponent { + fn new(element: HTMLElement) -> Self { + TodoListComponent { + shadow_root: attach_shadow(&element, true), + element, + } + } + fn connected(&mut self) { + self.render(); + let state = globals::get::(); + append_html(self.element,r#""#); + } +} + +impl TodoListComponent { + fn render(&mut self) { + set_html(&self.shadow_root, include_str!("todo-list.html")); + } +} + +struct TodoItemComponent { + element: HTMLElement, + shadow_root: HTMLElement, + is_done: bool, +} + +impl CustomElement for TodoItemComponent { + fn new(element: HTMLElement) -> Self { + TodoItemComponent { + shadow_root: attach_shadow(&element, true), + element: element, + is_done: false, + } + } + + fn connected(&mut self) { + set_html(&self.shadow_root, include_str!("todo-item.html")); + let btn = query_selector(&self.shadow_root, "button"); + add_event_listener( + &btn, + "click", + create_callback_0(|| { + js!(window.alert).invoke_1("I was clicked!"); + }), + ); + self.render(); + } + + fn observed_attributes() -> Vec<&'static str> { + vec!["done"] + } + + fn attribute_changed( + &mut self, + name: String, + _old_value: Option, + new_value: Option, + ) { + if name == "done" { + if let Some(value) = new_value { + if value == "yes" { + self.is_done = true; + } else { + self.is_done = false; + } + } else { + self.is_done = false; + } + } + self.render(); + } +} + +impl TodoItemComponent { + fn render(&mut self) { + if self.is_done { + log("done"); + } else { + log("not done"); + } + } +} + +#[no_mangle] +fn main() { + TodoListComponent::register("todo-list"); + TodoItemComponent::register("todo-item"); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/todo-item.html b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/todo-item.html new file mode 100644 index 0000000..46c2cf5 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/todo-item.html @@ -0,0 +1 @@ +
\ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/todo-list.html b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/todo-list.html new file mode 100644 index 0000000..5157361 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/examples/todo/src/todo-list.html @@ -0,0 +1,7 @@ +
+
+

Todo List

+
+
+
+
\ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/src/lib.rs new file mode 100644 index 0000000..8d3be6c --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/crates/webcomponent/src/lib.rs @@ -0,0 +1,147 @@ +#![no_std] +use js::*; +#[macro_use] +extern crate alloc; +use alloc::string::String; +use alloc::sync::Arc; +use alloc::vec::Vec; +use spin::Mutex; + +pub type HTMLElement = f64; + +#[derive(Copy, Clone)] +struct Destructable { + function: Option, +} + +pub trait CustomElement { + fn new(element: HTMLElement) -> Self + where + Self: core::marker::Sized + core::marker::Sync + core::marker::Send + 'static; + fn register(name: &str) + where + Self: core::marker::Sized + core::marker::Sync + core::marker::Send + 'static, + { + let construct = create_callback_1(|element| { + let el = Arc::new(Mutex::new(Self::new(element.into()))); + let el1 = el.clone(); + let el2 = el.clone(); + let el3 = el.clone(); + + let destruct_connect = Arc::new(Mutex::new(Destructable { function: None })); + let connect = create_callback_0(move || { + el1.lock().connected(); + }); + destruct_connect.lock().function = Some(connect.into()); + + let destruct_attribute_change = Arc::new(Mutex::new(Destructable { function: None })); + let attribute_change = create_callback_3(move |name_obj, old_obj, new_obj| { + let name = cstr_to_string(name_obj as i32); + let old = if old_obj == -1.0 { + None + } else { + Some(cstr_to_string(old_obj as i32)) + }; + let new = if new_obj == -1.0 { + None + } else { + Some(cstr_to_string(new_obj as i32)) + }; + el3.lock().attribute_changed(name, old, new); + }); + + destruct_attribute_change.lock().function = Some(connect.into()); + + let destruct_disconnect = Arc::new(Mutex::new(Destructable { function: None })); + let destruct_disconnect2 = destruct_disconnect.clone(); + let disconnect = create_callback_0(move || { + el2.lock().disconnected(); + remove_callback(destruct_connect.lock().function.as_ref().unwrap().into()); + remove_callback(destruct_disconnect.lock().function.as_ref().unwrap().into()); + remove_callback( + destruct_attribute_change + .lock() + .function + .as_ref() + .unwrap() + .into(), + ); + }); + destruct_disconnect2.lock().function = Some(disconnect.into()); + + lazy_static::lazy_static! { + static ref FN: JSFunction= { + register_function( + r#"function(e,a,b,c){ + e.addHooks(a,b,c); + }"#, + ) + };}; + FN.invoke_4(element, connect, disconnect, attribute_change); + }); + let attrs = Self::observed_attributes().join(","); + lazy_static::lazy_static! { + static ref FN: JSFunction= { + register_function( + r#"function(construct,elementNamePtr, elementNameLen,attrNamesPtr,attrNamesLen){ + const elementName = this.readUtf8FromMemory(elementNamePtr,elementNameLen); + const attrNames = this.readUtf8FromMemory(attrNamesPtr,attrNamesLen); + let attrs = attrNames.split(","); + class GeneratedCustomElement extends HTMLElement { + constructor() { + super(); + construct(this); + } + + static get observedAttributes() { + return attrs; + } + + connectedCallback() { + self.connect(); + } + + disconnectedCallback() { + self.disconnect(); + } + + attributeChangedCallback(attributeName, oldValue, newValue) { + self.attributeChange(attributeName,oldValue,newValue) + } + + addHooks(connect,disconnect,attributeChange){ + self.connect = connect; + self.disconnect = disconnect; + self.attributeChange = attributeChange; + } + } + + // tell the dom to associate it with an html tag name + customElements.define(elementName, GeneratedCustomElement); + }"#, + ) + };}; + FN.invoke_5( + construct, + name.as_ptr() as u32, + name.len() as u32, + attrs.as_ptr() as u32, + attrs.len() as u32, + ); + } + + fn observed_attributes() -> Vec<&'static str> { + vec![] + } + + fn created(&mut self) {} + fn connected(&mut self) {} + fn disconnected(&mut self) {} + fn attribute_changed( + &mut self, + _name: String, + _old_value: Option, + _new_value: Option, + ) { + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/electron/Cargo.toml b/__wasm/js-wasm/helloworld/js-wasm/electron/Cargo.toml new file mode 100644 index 0000000..a0fa613 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/electron/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "example" +version = "0.1.0" +authors = ["Richard "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +js = "0" + +[lib] +crate-type =["cdylib"] + +[profile.release] +lto = true \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/electron/Makefile b/__wasm/js-wasm/helloworld/js-wasm/electron/Makefile new file mode 100644 index 0000000..64c803d --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/electron/Makefile @@ -0,0 +1,27 @@ +build: tmp/electron.zip dist/js-wasm.js dist/app.wasm dist/index.html dist/index.js + +run: build + cd dist && ./electron . + + dist/index.js: index.js + cp index.js dist/index.js + +dist/app.wasm: src/**.rs + @RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release + @cp target/wasm32-unknown-unknown/release/example.wasm dist/app.wasm + +dist/js-wasm.js: + wget -O dist/js-wasm.js https://unpkg.com/js-wasm/js-wasm.js + +tmp/electron.zip: + mkdir -p tmp + mkdir -p dist + wget -O tmp/electron.zip https://github.com/electron/electron/releases/download/v11.0.2/electron-v11.0.2-linux-x64.zip + cd tmp && unzip electron.zip -d ../dist + +clean: + rm -rf dist + rm -rf tmp + +dist/index.html: index.html + cp index.html dist/index.html \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/electron/README.md b/__wasm/js-wasm/helloworld/js-wasm/electron/README.md new file mode 100644 index 0000000..a3408e8 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/electron/README.md @@ -0,0 +1,68 @@ +# Electron + WebAssembly = :heart: + +

+ +

+ + +Creating desktop apps with WebAssembly is as simple as making website! `electron` is a technology that packages chrome into an desktop app-like minimalistic web view experience. It gives the user access to the local systems resources via the `nodejs` JavaScript api. Since `js-wasm` is a technology agnostic library for executing javascript from WebAssembly, we can easily bind to the parts of the `electron` API we need. + +# Getting Started + +This directory contains an example to get started using quickly. + +``` +git clone git@github.com:richardanaya/js-wasm.git +cd js-wasm/electron +make run +``` + +Let's take a look at the various files: + +| File | Description | +|------|-------------| +| `index.js` | Electron wants a javascript file to tell it where to start, this is just basic setup you can tweak like starting width/height and does your app have a menubar. | +| `index.html` | This is the index file that gets loaded by `index.js` to be the first thing you see. Consider this just like any old web page. | + +All our `index.html` does is quickly tell WebAssembly to start like any old web application + +```html + + + My App! + + + + + + + + +``` + +## Getting what you need + +Now you can create JavaScript binding functions to invoke using [`js-wasm`](https://github.com/richardanaya/js-wasm/) as normal. + +```rust +pub fn read_file(msg: &str) -> String { + lazy_static::lazy_static! { + static ref FN: JSFunction= { + register_function( + "function(pathPtr,pathLen){ + const fs = require('fs'); + const data String(fs.readFileSync(this.readUtf8FromMemory(pathPtr,pathLen))); + return this.writeCStringToMemory(data); + }", + ) + };}; + cstr_to_string(FN.invoke_2(msg.as_ptr() as u32, msg.len() as u32) as i32) +} + +#[no_mangle] +pub fn main() { + let fileContent = read_file("foo.txt"); + ... +} +``` + diff --git a/__wasm/js-wasm/helloworld/js-wasm/electron/index.html b/__wasm/js-wasm/helloworld/js-wasm/electron/index.html new file mode 100644 index 0000000..c474536 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/electron/index.html @@ -0,0 +1,17 @@ + + + + My App! + + + + + + + + + \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/electron/index.js b/__wasm/js-wasm/helloworld/js-wasm/electron/index.js new file mode 100644 index 0000000..bc81259 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/electron/index.js @@ -0,0 +1,33 @@ +const {app, BrowserWindow} = require('electron') +function createWindow () { + const mainWindow = new BrowserWindow({ + width: 800, + height: 600, + webPreferences: { + // OPTIONAL: disable node integrations by commenting this line + nodeIntegration: true + } + }) + // OPTIONAL: Hide the menubar + // mainWindow.setMenu(null). + mainWindow.loadFile('index.html') + + // OPTIONAL: Open the DevTools on startup + // mainWindow.webContents.openDevTools() +} + +app.whenReady().then(() => { + createWindow() + app.on('activate', function () { + // On macOS it's common to re-create a window in the app when the + // dock icon is clicked and there are no other windows open. + if (BrowserWindow.getAllWindows().length === 0) createWindow() + }) +}) + +// Quit when all windows are closed, except on macOS. There, it's common +// for applications and their menu bar to stay active until the user quits +// explicitly with Cmd + Q. +app.on('window-all-closed', function () { + if (process.platform !== 'darwin') app.quit() +}) \ No newline at end of file diff --git a/__wasm/js-wasm/helloworld/js-wasm/electron/resources/webassembly.svg b/__wasm/js-wasm/helloworld/js-wasm/electron/resources/webassembly.svg new file mode 100644 index 0000000..9c08129 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/electron/resources/webassembly.svg @@ -0,0 +1,35 @@ + + + + + web-assembly-logo + + + + + + + + + + + + + + + + + + + + + + diff --git a/__wasm/js-wasm/helloworld/js-wasm/electron/src/lib.rs b/__wasm/js-wasm/helloworld/js-wasm/electron/src/lib.rs new file mode 100644 index 0000000..b1604a6 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/electron/src/lib.rs @@ -0,0 +1,37 @@ +#[no_mangle] +pub fn main() { + let fn_get_2d_context = js::register_function( + r#" + function(selectorStart, selectorEnd){ + let selector = this.readUtf8FromMemory(selectorStart,selectorEnd); + let obj = document.querySelector(selector); + return context.storeObject(obj.getContext("2d")); + }"#, + ); + let fn_set_color = js::register_function( + r#" + function(ctxHandle, colorStart, colorEnd){ + let color = this.readUtf8FromMemory(colorStart, colorEnd); + let ctx = this.getObject(ctxHandle); + ctx.fillStyle = color; + }"#, + ); + let fn_fill_rect = js::register_function( + r#" + function(ctxHandle, x, y, width, height){ + let ctx = this.getObject(ctxHandle); + ctx.fillRect(x, y, width, height); + }"#, + ); + let target = "#screen"; + let ctx = fn_get_2d_context.invoke_2(target.as_ptr() as u32,target.len() as u32); + let color = "red"; + fn_set_color.invoke_3(ctx, color.as_ptr() as u32, color.len() as u32); + fn_fill_rect.invoke_5(ctx, 10.0, 10.0, 50.0, 50.0); + let color = "blue"; + fn_set_color.invoke_3(ctx, color.as_ptr() as u32, color.len() as u32); + fn_fill_rect.invoke_5(ctx, 20.0, 20.0, 50.0, 50.0); + let color = "green"; + fn_set_color.invoke_3(ctx, color.as_ptr() as u32, color.len() as u32); + fn_fill_rect.invoke_5(ctx, 30.0, 30.0, 50.0, 50.0); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/headers/js-wasm.h b/__wasm/js-wasm/helloworld/js-wasm/headers/js-wasm.h new file mode 100644 index 0000000..2dfdd38 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/headers/js-wasm.h @@ -0,0 +1,63 @@ +#ifndef export +#define export __attribute__((visibility("default"))) +#endif + +#ifndef JS_H + +unsigned int +js_strlen(const char *str) +{ + const char *s; + + for (s = str; *s; ++s) + ; + return (s - str); +} + +typedef double JSValue; +typedef int JSFunction; +extern JSFunction js_register_function(char*,unsigned int); +extern JSValue js_invoke_function(JSFunction,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue); +extern void js_release(JSValue); + +JSValue const JS_NULL = 0.0; +JSValue const JS_UNDEFINED = 1.0; +JSValue const DOM_SELF = 2.0; +JSValue const DOM_WINDOW = 2.0; +JSValue const DOM_DOCUMENT = 3.0; +JSValue const DOM_BODY = 4.0; + +JSValue js_invoke_function_0(JSFunction fn){ + return js_invoke_function(fn,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0); +} +JSValue js_invoke_function_1(JSFunction fn, JSValue a){ + return js_invoke_function(fn,a,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0); +} +JSValue js_invoke_function_2(JSFunction fn, JSValue a, JSValue b){ + return js_invoke_function(fn,a,b,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0); +} +JSValue js_invoke_function_3(JSFunction fn, JSValue a, JSValue b, JSValue c){ + return js_invoke_function(fn,a,b,c,0.0,0.0,0.0,0.0,0.0,0.0,0.0); +} +JSValue js_invoke_function_4(JSFunction fn, JSValue a, JSValue b, JSValue c, JSValue d){ + return js_invoke_function(fn,a,b,c,d,0.0,0.0,0.0,0.0,0.0,0.0); +} +JSValue js_invoke_function_5(JSFunction fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e){ + return js_invoke_function(fn,a,b,c,d,e,0.0,0.0,0.0,0.0,0.0); +} +JSValue js_invoke_function_6(JSFunction fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f){ + return js_invoke_function(fn,a,b,c,d,e,f,0.0,0.0,0.0,0.0); +} +JSValue js_invoke_function_7(JSFunction fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g){ + return js_invoke_function(fn,a,b,c,d,e,f,g,0.0,0.0,0.0); +} +JSValue js_invoke_function_8(JSFunction fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g, JSValue h){ + return js_invoke_function(fn,a,b,c,d,e,f,g,h,0.0,0.0); +} +JSValue js_invoke_function_9(JSFunction fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g, JSValue h, JSValue i){ + return js_invoke_function(fn,a,b,c,d,e,f,g,h,i,0.0); +} +JSValue js_invoke_function_10(JSFunction fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g, JSValue h, JSValue i, JSValue j){ + return js_invoke_function(fn,a,b,c,d,e,f,g,h,i,j); +} +#endif diff --git a/__wasm/js-wasm/helloworld/js-wasm/headers/web_canvas.h b/__wasm/js-wasm/helloworld/js-wasm/headers/web_canvas.h new file mode 100644 index 0000000..3530e4c --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/headers/web_canvas.h @@ -0,0 +1 @@ +#include "js-wasm.h" diff --git a/__wasm/js-wasm/helloworld/js-wasm/headers/web_console.h b/__wasm/js-wasm/helloworld/js-wasm/headers/web_console.h new file mode 100644 index 0000000..26c41d3 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/headers/web_console.h @@ -0,0 +1,65 @@ +#include "js-wasm.h" + +void console_clear(){ + static int fn; + char *fn_code = "function(){ console.clear(); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_0(fn); +} + +void console_log(char * msg){ + static int fn; + unsigned int a0 = (unsigned int)msg; + unsigned int a1 = js_strlen(msg); + char *fn_code = "function(msgPtr,msgLen){ console.log(this.readUtf8FromMemory(msgPtr,msgLen)); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_2(fn, a0, a1); +} + +void console_warning(char * msg){ + static int fn; + unsigned int a0 = (unsigned int)msg; + unsigned int a1 = js_strlen(msg); + char *fn_code = "function(msgPtr,msgLen){ console.warn(this.readUtf8FromMemory(msgPtr,msgLen)); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_2(fn, a0, a1); +} + +void console_error(char * msg){ + static int fn; + unsigned int a0 = (unsigned int)msg; + unsigned int a1 = js_strlen(msg); + char *fn_code = "function(msgPtr,msgLen){ console.error(this.readUtf8FromMemory(msgPtr,msgLen)); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_2(fn, a0, a1); +} + +void console_time(char * msg){ + static int fn; + unsigned int a0 = (unsigned int)msg; + unsigned int a1 = js_strlen(msg); + char *fn_code = "function(msgPtr,msgLen){ console.time(this.readUtf8FromMemory(msgPtr,msgLen)); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_2(fn, a0, a1); +} + +void console_time_end(char * msg){ + static int fn; + unsigned int a0 = (unsigned int)msg; + unsigned int a1 = js_strlen(msg); + char *fn_code = "function(msgPtr,msgLen){ console.timeEnd(this.readUtf8FromMemory(msgPtr,msgLen)); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + js_invoke_function_2(fn, a0, a1); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/headers/web_dom.h b/__wasm/js-wasm/helloworld/js-wasm/headers/web_dom.h new file mode 100644 index 0000000..969104c --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/headers/web_dom.h @@ -0,0 +1,12 @@ +#include "js-wasm.h" + +double document_get_element_by_id(char * id){ + static int fn; + unsigned int a0 = (unsigned int)id; + unsigned int a1 = js_strlen(id); + char *fn_code = "function(idPtr,idLen){ return this.storeObject(document.getElementById(this.readUtf8FromMemory(idPtr,idLen))); }"; + if(fn == 0){ + fn = js_register_function(fn_code,js_strlen(fn_code)); + } + return js_invoke_function_2(fn, a0, a1); +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/js-wasm.js b/__wasm/js-wasm/helloworld/js-wasm/js-wasm.js new file mode 100644 index 0000000..5ab7765 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/js-wasm.js @@ -0,0 +1,244 @@ +"use strict"; +class Index { + constructor(index, generation) { + this.index = index; + this.generation = generation; + } + toNum() { + return Number((BigInt(this.generation) << BigInt(32)) | BigInt(this.index)); + } + static fromNum(n) { + const i = Number(((BigInt(n) & BigInt(0xffffffff00000000)) >> BigInt(32)) & + BigInt(0xffffffff)); + const g = n & 0xffffffff; + return new Index(g, i); + } +} +class GenerationalArena { + constructor() { + this.items = []; + this.generation = 0; + this.free_list_head = undefined; + this.length = 0; + } + insert(v) { + // lets use the first free entry if we have one + if (this.free_list_head !== undefined) { + let i = this.free_list_head; + this.free_list_head = this.items[i].nextFree; + this.items[i] = { + generation: this.generation, + value: v, + }; + this.length += 1; + return new Index(i, this.generation); + } + this.items.push({ + generation: this.generation, + value: v, + }); + const idx = new Index(this.items.length - 1, this.generation); + this.length += 1; + return idx; + } + contains(idx) { + return this.get(idx) !== undefined; + } + get(i) { + let e = this.items[i.index]; + if (e && e.generation === i.generation) { + return e.value; + } + return undefined; + } + remove(idx) { + if (idx.index >= this.items.length) { + return undefined; + } + let e = this.items[idx.index]; + if (e.generation !== undefined && e.generation == idx.generation) { + this.generation += 1; + this.items[idx.index] = { + nextFree: this.free_list_head, + }; + this.free_list_head = idx.index; + this.length -= 1; + return e.value; + } + return undefined; + } + *[Symbol.iterator]() { + for (let i = 0; i < this.items.length; i++) { + const x = this.items[i]; + if (x.generation !== undefined) { + yield { index: new Index(i, x.generation), value: x.value }; + } + } + } + indices() { + return { + items: this.items, + [Symbol.iterator]: function* iter() { + for (let i = 0; i < this.items.length; i++) { + const x = this.items[i]; + if (x.generation !== undefined) { + yield new Index(i, x.generation); + } + } + }, + }; + } + values() { + return { + items: this.items, + [Symbol.iterator]: function* iter() { + for (let i = 0; i < this.items.length; i++) { + const x = this.items[i]; + if (x.generation !== undefined) { + yield x.value; + } + } + }, + }; + } +} +const JsWasm = { + createEnvironment() { + const arena = new GenerationalArena(); + arena.insert(undefined); + arena.insert(null); + arena.insert(self); + arena.insert(typeof document != "undefined" ? document : null); + arena.insert(typeof document != "undefined" ? document.body : null); + const context = { + functions: [ + function () { + debugger; + return 0; + }, + ], + objects: arena, + utf8dec: new TextDecoder("utf-8"), + utf8enc: new TextEncoder(), + utf16dec: new TextDecoder("utf-16"), + toCallbackArg: function (arg) { + if (typeof arg === "object") { + return context.storeObject(arg); + } + return arg; + }, + createCallback: function (cb) { + if (!this.module) { + throw new Error("module not set"); + } + const fnHandleCallback = this.module.instance.exports.handle_callback; + return function () { + const arg = arguments; + fnHandleCallback(cb, context.toCallbackArg(arg[0]), context.toCallbackArg(arg[1]), context.toCallbackArg(arg[2]), context.toCallbackArg(arg[3]), context.toCallbackArg(arg[4]), context.toCallbackArg(arg[5]), context.toCallbackArg(arg[6]), context.toCallbackArg(arg[7]), context.toCallbackArg(arg[8]), context.toCallbackArg(arg[9])); + }; + }, + readUtf8FromMemory: function (start, len) { + const text = this.utf8dec.decode(this.getMemory().subarray(start, start + len)); + return text; + }, + createAllocation: function (size) { + if (!this.module) { + throw new Error("module not set"); + } + const allocationId = this.module.instance.exports.create_allocation(size); + const allocationPtr = this.module.instance.exports.allocation_ptr(allocationId); + return [allocationId, allocationPtr]; + }, + writeUtf8ToMemory: function (str) { + const bytes = this.utf8enc.encode(str); + const len = bytes.length; + const [id, start] = this.createAllocation(len); + this.getMemory().set(bytes, start); + return id; + }, + readUtf16FromMemory: function (start, len) { + const text = this.utf16dec.decode(this.getMemory().subarray(start, start + len)); + return text; + }, + readUint8ArrayFromMemory(start) { + if (!this.module) { + throw new Error("module not set"); + } + const data32 = new Uint32Array(this.module.instance.exports.memory.buffer); + const ptr = data32[start / 4]; + const length = data32[ptr / 4]; + let b = this.getMemory().slice(ptr + 4, ptr + 4 + length); + return new Uint8Array(b); + }, + storeObject: function (obj) { + const index = this.objects.insert(obj); + return index.toNum(); + }, + getObject: function (handle) { + return this.objects.get(Index.fromNum(handle)); + }, + releaseObject: function (handle) { + this.objects.remove(Index.fromNum(handle)); + }, + getMemory: function () { + if (!this.module) { + throw new Error("module not set"); + } + return new Uint8Array(this.module.instance.exports.memory.buffer); + }, + }; + return [{ + abort() { + throw new Error("WebAssembly module aborted"); + }, + js_release(obj) { + context.releaseObject(obj); + }, + js_register_function(start, len, utfByteLen) { + let functionBody; + if (utfByteLen === 16) { + functionBody = context.readUtf16FromMemory(start, len); + } + else { + functionBody = context.readUtf8FromMemory(start, len); + } + let id = context.functions.length; + context.functions.push(Function(`"use strict";return(${functionBody})`)()); + return id; + }, + js_invoke_function(funcHandle, a, b, c, d, e, f, g, h, i, j) { + return context.functions[funcHandle].call(context, a, b, c, d, e, f, g, h, i, j); + }, + }, context]; + }, + async loadAndRunWasm(wasmURL) { + const [env, context] = JsWasm.createEnvironment(); + const response = await fetch(wasmURL); + const bytes = await response.arrayBuffer(); + const module = await WebAssembly.instantiate(bytes, { + env, + }); + context.module = module; + module.instance.exports.main(); + }, +}; +document.addEventListener("DOMContentLoaded", function () { + const wasmScripts = document.querySelectorAll("script[type='application/wasm']"); + for (let i = 0; i < wasmScripts.length; i++) { + const src = wasmScripts[i].src; + if (src) { + JsWasm.loadAndRunWasm(src); + } + else { + console.error("Script tag must have 'src' property."); + } + } +}); +if (window.WasmScriptComponents) { + window.WasmScriptComponents["js-wasm"] = function (e) { + return { + ...e, + ...JsWasm.createEnvironment(), + }; + }; +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/js-wasm.ts b/__wasm/js-wasm/helloworld/js-wasm/js-wasm.ts new file mode 100644 index 0000000..cbb3736 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/js-wasm.ts @@ -0,0 +1,368 @@ +class Index { + index: number; + generation: number; + + constructor(index: number, generation: number) { + this.index = index; + this.generation = generation; + } + + toNum() { + return Number((BigInt(this.generation) << BigInt(32)) | BigInt(this.index)); + } + + static fromNum(n: number) { + const i = Number( + ((BigInt(n) & BigInt(0xffffffff00000000)) >> BigInt(32)) & + BigInt(0xffffffff) + ); + const g = n & 0xffffffff; + return new Index(g, i); + } +} + +interface GenerationItem { + generation?: number; + value?: T; + nextFree?: number; +} + +class GenerationalArena { + items: GenerationItem[]; + generation: number; + length: number; + free_list_head?: number; + + constructor() { + this.items = []; + this.generation = 0; + this.free_list_head = undefined; + this.length = 0; + } + + insert(v: T) { + // lets use the first free entry if we have one + if (this.free_list_head !== undefined) { + let i = this.free_list_head; + this.free_list_head = this.items[i].nextFree; + this.items[i] = { + generation: this.generation, + value: v, + }; + this.length += 1; + return new Index(i, this.generation); + } + + this.items.push({ + generation: this.generation, + value: v, + }); + const idx = new Index(this.items.length - 1, this.generation); + this.length += 1; + return idx; + } + + contains(idx: Index) { + return this.get(idx) !== undefined; + } + + get(i: Index) { + let e = this.items[i.index]; + if (e && e.generation === i.generation) { + return e.value; + } + return undefined; + } + + remove(idx: Index) { + if (idx.index >= this.items.length) { + return undefined; + } + + let e = this.items[idx.index]; + if (e.generation !== undefined && e.generation == idx.generation) { + this.generation += 1; + this.items[idx.index] = { + nextFree: this.free_list_head, + }; + this.free_list_head = idx.index; + this.length -= 1; + return e.value; + } + return undefined; + } + + *[Symbol.iterator]() { + for (let i = 0; i < this.items.length; i++) { + const x = this.items[i]; + if (x.generation !== undefined) { + yield { index: new Index(i, x.generation), value: x.value }; + } + } + } + + indices() { + return { + items: this.items, + [Symbol.iterator]: function* iter() { + for (let i = 0; i < this.items.length; i++) { + const x = this.items[i]; + if (x.generation !== undefined) { + yield new Index(i, x.generation); + } + } + }, + }; + } + + values() { + return { + items: this.items, + [Symbol.iterator]: function* iter() { + for (let i = 0; i < this.items.length; i++) { + const x = this.items[i]; + if (x.generation !== undefined) { + yield x.value; + } + } + }, + }; + } +} + +interface JSWasmHandlerContext { + functions: (( + a: number, + b: number, + c: number, + d: number, + e: number, + f: number, + g: number, + h: number, + i: number, + j: number + ) => number)[]; + objects: GenerationalArena; + utf8dec: TextDecoder; + utf8enc: TextEncoder; + utf16dec: TextDecoder; + toCallbackArg: (arg: number | object) => number; + storeObject: (obj: any) => number; + releaseObject: (objHandle: number) => void; + module?: WebAssembly.WebAssemblyInstantiatedSource; + readUtf8FromMemory: (start: number, end: number) => string; + readUtf16FromMemory: (start: number, end: number) => string; + getMemory: () => Uint8Array; + createAllocation: (size: number) => [number,number] ; + createCallback: (cb: number) => () => void; + writeUtf8ToMemory: (txt: string) => number; + readUint8ArrayFromMemory: (start: number) => Uint8Array; + getObject: (handle: number) => any; +} + +const JsWasm = { + createEnvironment(): [WebAssembly.ModuleImports, JSWasmHandlerContext] { + const arena = new GenerationalArena(); + arena.insert(undefined); + arena.insert(null); + arena.insert(self); + arena.insert(typeof document != "undefined" ? document : null); + arena.insert(typeof document != "undefined" ? document.body : null); + const context: JSWasmHandlerContext = { + functions: [ + function () { + debugger; + return 0; + }, + ], + objects: arena, + utf8dec: new TextDecoder("utf-8"), + utf8enc: new TextEncoder(), + utf16dec: new TextDecoder("utf-16"), + toCallbackArg: function (arg: number | object) { + if (typeof arg === "object") { + return context.storeObject(arg); + } + return arg; + }, + createCallback: function (cb: number) { + if (!this.module) { + throw new Error("module not set"); + } + const fnHandleCallback = this.module.instance.exports.handle_callback as ( + cb: number, + a: number, + b: number, + c: number, + d: number, + e: number, + f: number, + g: number, + h: number, + i: number, + j: number + ) => void; + return function () { + const arg = arguments; + fnHandleCallback( + cb, + context.toCallbackArg(arg[0]), + context.toCallbackArg(arg[1]), + context.toCallbackArg(arg[2]), + context.toCallbackArg(arg[3]), + context.toCallbackArg(arg[4]), + context.toCallbackArg(arg[5]), + context.toCallbackArg(arg[6]), + context.toCallbackArg(arg[7]), + context.toCallbackArg(arg[8]), + context.toCallbackArg(arg[9]) + ); + }; + }, + readUtf8FromMemory: function (start: number, len: number) { + const text = this.utf8dec.decode( + this.getMemory().subarray(start, start + len) + ); + return text; + }, + createAllocation: function (size: number): [number,number] { + if (!this.module) { + throw new Error("module not set"); + } + const allocationId = (this.module.instance.exports.create_allocation as ( + size: number + ) => number)(size); + const allocationPtr = (this.module.instance.exports.allocation_ptr as ( + size: number + ) => number)(allocationId); + return [allocationId, allocationPtr]; + }, + writeUtf8ToMemory: function (str: string) { + const bytes = this.utf8enc.encode(str); + const len = bytes.length; + const [id,start] = this.createAllocation(len); + this.getMemory().set(bytes, start); + return id; + }, + readUtf16FromMemory: function (start: number, len: number) { + const text = this.utf16dec.decode( + this.getMemory().subarray(start, start + len) + ); + return text; + }, + readUint8ArrayFromMemory(start: number) { + if (!this.module) { + throw new Error("module not set"); + } + const data32 = new Uint32Array( + (this.module.instance.exports.memory as WebAssembly.Memory).buffer + ); + const ptr = data32[start / 4]; + const length = data32[ptr / 4]; + let b = this.getMemory().slice(ptr + 4, ptr + 4 + length); + return new Uint8Array(b); + }, + storeObject: function (obj: unknown) { + const index = this.objects.insert(obj); + return index.toNum(); + }, + getObject: function (handle: number) { + return this.objects.get(Index.fromNum(handle)); + }, + releaseObject: function (handle: number) { + this.objects.remove(Index.fromNum(handle)); + }, + getMemory: function () { + if (!this.module) { + throw new Error("module not set"); + } + return new Uint8Array( + (this.module.instance.exports.memory as WebAssembly.Memory).buffer + ); + }, + }; + return [{ + abort() { + throw new Error("WebAssembly module aborted"); + }, + js_release(obj: number) { + context.releaseObject(obj); + }, + js_register_function(start: number, len: number, utfByteLen: number) { + let functionBody; + if (utfByteLen === 16) { + functionBody = context.readUtf16FromMemory(start, len); + } else { + functionBody = context.readUtf8FromMemory(start, len); + } + let id = context.functions.length; + context.functions.push( + Function(`"use strict";return(${functionBody})`)() + ); + return id; + }, + js_invoke_function( + funcHandle: number, + a: number, + b: number, + c: number, + d: number, + e: number, + f: number, + g: number, + h: number, + i: number, + j: number + ) { + return context.functions[funcHandle].call( + context, + a, + b, + c, + d, + e, + f, + g, + h, + i, + j + ); + }, + },context]; + }, + + async loadAndRunWasm(wasmURL: string) { + const [env,context] = JsWasm.createEnvironment(); + const response = await fetch(wasmURL); + const bytes = await response.arrayBuffer(); + const module = await WebAssembly.instantiate(bytes, { + env, + }); + context.module = module; + (module.instance.exports.main as ()=>void)(); + }, +}; + +document.addEventListener("DOMContentLoaded", function () { + const wasmScripts = document.querySelectorAll( + "script[type='application/wasm']" + ); + for (let i = 0; i < wasmScripts.length; i++) { + const src = (wasmScripts[i] as HTMLSourceElement).src; + if (src) { + JsWasm.loadAndRunWasm(src); + } else { + console.error("Script tag must have 'src' property."); + } + } +}); + +if ((window as any).WasmScriptComponents) { + (window as any).WasmScriptComponents["js-wasm"] = function (e: any) { + return { + ...e, + ...JsWasm.createEnvironment(), + }; + }; +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/package-lock.json b/__wasm/js-wasm/helloworld/js-wasm/package-lock.json new file mode 100644 index 0000000..e33411d --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/package-lock.json @@ -0,0 +1,36 @@ +{ + "name": "js-wasm", + "version": "0.3.1", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "version": "0.3.1", + "license": "MIT OR Apache-2.0", + "devDependencies": { + "typescript": "^4.7" + } + }, + "node_modules/typescript": { + "version": "4.7.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.4.tgz", + "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==", + "dev": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + } + }, + "dependencies": { + "typescript": { + "version": "4.7.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.4.tgz", + "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==", + "dev": true + } + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/package.json b/__wasm/js-wasm/helloworld/js-wasm/package.json new file mode 100644 index 0000000..27af7f7 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/package.json @@ -0,0 +1,33 @@ +{ + "name": "js-wasm", + "version": "0.4.1", + "description": "Call JavaScript from WebAssembly ", + "main": "js-wasm.js", + "directories": { + "example": "examples" + }, + "scripts": { + "build": "tsc -p tsconfig.json", + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/richardanaya/js-wasm.git" + }, + "keywords": [ + "wasm", + "js" + ], + "author": "Richard Anaya", + "license": "MIT OR Apache-2.0", + "bugs": { + "url": "https://github.com/richardanaya/js-wasm/issues" + }, + "homepage": "https://github.com/richardanaya/js-wasm#readme", + "files": [ + "js-wasm.js" + ], + "devDependencies": { + "typescript": "^4.7" + } +} diff --git a/__wasm/js-wasm/helloworld/js-wasm/tsconfig.json b/__wasm/js-wasm/helloworld/js-wasm/tsconfig.json new file mode 100644 index 0000000..88838e2 --- /dev/null +++ b/__wasm/js-wasm/helloworld/js-wasm/tsconfig.json @@ -0,0 +1,74 @@ +{ + "compilerOptions": { + /* Visit https://aka.ms/tsconfig.json to read more about this file */ + + /* Basic Options */ + // "incremental": true, /* Enable incremental compilation */ + "target": "es2020", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */ + //"module": "es2020", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */ + "lib": ["es2020","DOM"], + // "allowJs": true, /* Allow javascript files to be compiled. */ + // "checkJs": true, /* Report errors in .js files. */ + // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */ + // "declaration": true, /* Generates corresponding '.d.ts' file. */ + // "declarationMap": true, /* Generates a sourcemap for each corresponding '.d.ts' file. */ + // "sourceMap": true, /* Generates corresponding '.map' file. */ + "outFile": "js-wasm.js", /* Concatenate and emit output to single file. */ + // "outDir": "./", /* Redirect output structure to the directory. */ + // "rootDir": "./", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */ + // "composite": true, /* Enable project compilation */ + // "tsBuildInfoFile": "./", /* Specify file to store incremental compilation information */ + // "removeComments": true, /* Do not emit comments to output. */ + // "noEmit": true, /* Do not emit outputs. */ + // "importHelpers": true, /* Import emit helpers from 'tslib'. */ + // "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */ + // "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */ + + /* Strict Type-Checking Options */ + "strict": true, /* Enable all strict type-checking options. */ + // "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */ + // "strictNullChecks": true, /* Enable strict null checks. */ + // "strictFunctionTypes": true, /* Enable strict checking of function types. */ + // "strictBindCallApply": true, /* Enable strict 'bind', 'call', and 'apply' methods on functions. */ + // "strictPropertyInitialization": true, /* Enable strict checking of property initialization in classes. */ + // "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */ + // "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */ + + /* Additional Checks */ + // "noUnusedLocals": true, /* Report errors on unused locals. */ + // "noUnusedParameters": true, /* Report errors on unused parameters. */ + // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */ + // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */ + // "noUncheckedIndexedAccess": true, /* Include 'undefined' in index signature results */ + // "noPropertyAccessFromIndexSignature": true, /* Require undeclared properties from index signatures to use element accesses. */ + + /* Module Resolution Options */ + // "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */ + // "baseUrl": "./", /* Base directory to resolve non-absolute module names. */ + // "paths": {}, /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */ + // "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */ + // "typeRoots": [], /* List of folders to include type definitions from. */ + // "types": [], /* Type declaration files to be included in compilation. */ + // "allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */ + "esModuleInterop": true, /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */ + // "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */ + // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */ + + /* Source Map Options */ + // "sourceRoot": "", /* Specify the location where debugger should locate TypeScript files instead of source locations. */ + // "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */ + // "inlineSourceMap": true, /* Emit a single file with source maps instead of having a separate file. */ + // "inlineSources": true, /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */ + + /* Experimental Options */ + // "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */ + // "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */ + + /* Advanced Options */ + "skipLibCheck": true, /* Skip type checking of declaration files. */ + "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */ + }, + "files": [ + "js-wasm.ts" + ] +}