diff --git a/templates/decky/.gitignore b/templates/decky/.gitignore new file mode 100644 index 0000000..9e0f121 --- /dev/null +++ b/templates/decky/.gitignore @@ -0,0 +1,50 @@ +lib-cov +*.seed +*.log +*.csv +*.dat +*.out +*.pid +*.gz +*.swp + +pids +logs +results +tmp + +# Coverage reports +coverage + +# API keys and secrets +.env + +# Dependency directory +node_modules +bower_components + +# Editors +.idea +*.iml + +# OS metadata +.DS_Store +Thumbs.db + +# Ignore built ts files +dist/ + +__pycache__/ + +/.yalc +yalc.lock + +.vscode/settings.json + +# ignore Rust compiler files +/backend-rs/target +backend +/bin + +# packaged teasers +*.zip diff --git a/templates/decky/.vscode/config.sh b/templates/decky/.vscode/config.sh new file mode 100755 index 0000000..b45c794 --- /dev/null +++ b/templates/decky/.vscode/config.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]:-$0}"; )" &> /dev/null && pwd 2> /dev/null; )"; +# printf "${SCRIPT_DIR}\n" +# printf "$(dirname $0)\n" +if ! [[ -e "${SCRIPT_DIR}/settings.json" ]]; then + printf '.vscode/settings.json does not exist. Creating it with default settings. Exiting afterwards. Run your task again.\n\n' + cp "${SCRIPT_DIR}/defsettings.json" "${SCRIPT_DIR}/settings.json" + exit 1 +else + printf '.vscode/settings.json does exist. Congrats.\n' + printf 'Make sure to change settings.json to match your deck.\n' +fi \ No newline at end of file diff --git a/templates/decky/.vscode/defsettings.json b/templates/decky/.vscode/defsettings.json new file mode 100644 index 0000000..7360735 --- /dev/null +++ b/templates/decky/.vscode/defsettings.json @@ -0,0 +1,7 @@ +{ + "deckip" : "0.0.0.0", + "deckport" : "22", + "deckpass" : "ssap", + "deckkey" : "-i ${env:HOME}/.ssh/id_rsa", + "deckdir" : "/home/deck" +} \ No newline at end of file diff --git a/templates/decky/.vscode/tasks.json b/templates/decky/.vscode/tasks.json new file mode 100644 index 0000000..71d03df --- /dev/null +++ b/templates/decky/.vscode/tasks.json @@ -0,0 +1,105 @@ +{ + "version": "2.0.0", + "tasks": [ + // OTHER + { + "label": "checkforsettings", + "type": "shell", + "group": "none", + "detail": "Check that settings.json has been created", + "command": "bash -c ${workspaceFolder}/.vscode/config.sh", + "problemMatcher": [] + }, + // BUILD + { + "label": "pnpmsetup", + "type": "shell", + "group": "build", + "detail": "Setup pnpm", + "command": "pnpm i", + "problemMatcher": [] + }, + { + "label": "updatefrontendlib", + "type": "shell", + "group": "build", + "detail": "Update deck-frontend-lib", + "command": "pnpm update decky-frontend-lib --latest", + "problemMatcher": [] + }, + { + "label": "build", + "type": "npm", + "group": "build", + "detail": "rollup -c", + "script": "build", + "path": "", + "problemMatcher": [] + }, + { + "label": "buildall", + "group": "build", + "detail": "Build decky-plugin-template", + "dependsOrder": "sequence", + "dependsOn": [ + "pnpmsetup", + "build" + ], + "problemMatcher": [] + }, + // DEPLOY + { + "label": "createfolders", + "detail": "Create plugins folder in expected directory", + "type": "shell", + "group": "none", + "dependsOn": [ + "checkforsettings" + ], + "command": "ssh deck@${config:deckip} -p ${config:deckport} ${config:deckkey} 'mkdir -p ${config:deckdir}/homebrew/dev/pluginloader && mkdir -p ${config:deckdir}/homebrew/dev/plugins'", + "problemMatcher": [] + }, + { + "label": "deploy", + "detail": "Deploy dev plugin to deck", + "type": "shell", + "group": "none", + "dependsOn": [ + "createfolders", + "chmodfolders" + ], + "command": "rsync -azp --delete --rsh='ssh -p ${config:deckport} ${config:deckkey}' --exclude='.git/' --exclude='.github/' --exclude='.vscode/' --exclude='node_modules/' --exclude='src/' --exclude='*.log' --exclude='.gitignore' . deck@${config:deckip}:${config:deckdir}/homebrew/dev/plugins/${workspaceFolderBasename}", + "problemMatcher": [] + }, + { + "label": "chmodfolders", + "detail": "chmods folders to prevent perms issues", + "type": "shell", + "group": "none", + "command": "ssh deck@${config:deckip} -p ${config:deckport} ${config:deckkey} 'echo '${config:deckpass}' | sudo -S chmod -R ug+rw ${config:deckdir}/homebrew/dev/'", + "problemMatcher": [] + }, + { + "label": "deployall", + "dependsOrder": "sequence", + "group": "none", + "dependsOn": [ + "deploy", + "chmodfolders" + ], + "problemMatcher": [] + }, + // ALL-IN-ONE + { + "label": "allinone", + "detail": "Build and deploy", + "dependsOrder": "sequence", + "group": "test", + "dependsOn": [ + "buildall", + "deployall" + ], + "problemMatcher": [] + } + ] +} diff --git a/templates/decky/README.md b/templates/decky/README.md new file mode 100644 index 0000000..04401c8 --- /dev/null +++ b/templates/decky/README.md @@ -0,0 +1,37 @@ +# React-Frontend Plugin Template + +Reference example for using [decky-frontend-lib](https://github.com/SteamDeckHomebrew/decky-frontend-lib) in a [PluginLoader](https://github.com/SteamDeckHomebrew/PluginLoader) plugin. + +## PluginLoader Discord [![Chat](https://img.shields.io/badge/chat-on%20discord-7289da.svg)](https://discord.gg/ZU74G2NJzk) + +## Developers + +### Dependencies + +This template relies on the user having `pnpm` installed on their system. +This can be downloaded from `npm` itself which is recommended. + +#### Linux + +```bash +sudo npm i -g pnpm +``` + +### Getting Started + +1. Clone the repository to use as an example for making your plugin. +2. In your clone of the repository run these commands: + 1. ``pnpm i`` + 2. ``pnpm run build`` +3. You should do this every time you make changes to your plugin. + +Note: If you are recieveing build errors due to an out of date library, you should run this command inside of your repository: + +```bash +pnpm update decky-frontend-lib --latest +``` + +### Distribution + +WIP. Check back in later. + diff --git a/templates/decky/assets/logo.png b/templates/decky/assets/logo.png new file mode 100644 index 0000000..48c4851 Binary files /dev/null and b/templates/decky/assets/logo.png differ diff --git a/templates/decky/defaults/defaults.txt b/templates/decky/defaults/defaults.txt new file mode 100644 index 0000000..ebf140b --- /dev/null +++ b/templates/decky/defaults/defaults.txt @@ -0,0 +1,13 @@ +If you have plain-text json configs, theme templates, or templates for usage for your plugin of any description you should have those files be in here. +Those files will be pulled into the zip during the build process and included with the upload. Example: CssLoader with it's themes in "default/themes" would have the "themes" folder will be added alongside with the dist folder, main.py, LICENSE and README files in the subfolder of the zip containing the plugin. +Files can also be put in here such as a config, just keep in mind that they this directory cannot be utilized to put files in arbitrary locations, just within the extracted root folder of the plugin, ex: CssLoader has "defaults/themes/..." setup in it's repo, but when packaged to go to the store, the file structure will be: + +- LICENSE +- README +- dist + - index.js +- main.py +- package.json +- plugin.json +- themes + - exampletheme.css \ No newline at end of file diff --git a/templates/decky/main.py b/templates/decky/main.py new file mode 100644 index 0000000..e7435f5 --- /dev/null +++ b/templates/decky/main.py @@ -0,0 +1,16 @@ +import pathlib +import subprocess +import asyncio +import os + +HOME_DIR = str(pathlib.Path(os.getcwd()).parent.parent.resolve()) +PARENT_DIR = str(pathlib.Path(__file__).parent.resolve()) + +class Plugin: + backend_proc = None + # Asyncio-compatible long-running code, executed in a task when the plugin is loaded + async def _main(self): + # startup + self.backend_proc = subprocess.Popen([PARENT_DIR + "/bin/backend"]) + while True: + asyncio.sleep(1) diff --git a/templates/decky/package.json b/templates/decky/package.json new file mode 100644 index 0000000..cfd9a0f --- /dev/null +++ b/templates/decky/package.json @@ -0,0 +1,54 @@ +{ + "name": "decky-plugin-template", + "version": "0.0.1", + "description": "A template to quickly create decky plugins from scratch, based on TypeScript and webpack", + "scripts": { + "build": "shx rm -rf dist && rollup -c", + "watch": "rollup -c -w", + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/SteamDeckHomebrew/decky-plugin-template.git" + }, + "keywords": [ + "decky", + "plugin", + "plugin-template", + "steam-deck", + "deck" + ], + "author": "Jonas Dellinger ", + "license": "GPL-2.0-or-later", + "bugs": { + "url": "https://github.com/SteamDeckHomebrew/decky-plugin-template/issues" + }, + "homepage": "https://github.com/SteamDeckHomebrew/decky-plugin-template#readme", + "devDependencies": { + "@rollup/plugin-commonjs": "^21.1.0", + "@rollup/plugin-json": "^4.1.0", + "@rollup/plugin-node-resolve": "^13.2.1", + "@rollup/plugin-replace": "^4.0.0", + "@rollup/plugin-typescript": "^8.3.2", + "@types/react": "16.14.0", + "@types/webpack": "^5.28.0", + "rollup": "^2.70.2", + "rollup-plugin-import-assets": "^1.1.1", + "shx": "^0.3.4", + "tslib": "^2.4.0", + "typescript": "^4.6.4" + }, + "dependencies": { + "decky-frontend-lib": "^1.0.1", + "react-icons": "^4.3.1", + "usdpl-front": "file:./src/usdpl-front" + }, + "pnpm": { + "peerDependencyRules": { + "ignoreMissing": [ + "react", + "react-dom" + ] + } + } +} diff --git a/templates/decky/plugin.json b/templates/decky/plugin.json new file mode 100644 index 0000000..226eec9 --- /dev/null +++ b/templates/decky/plugin.json @@ -0,0 +1,10 @@ +{ + "name": "Example Plugin", + "author": "John Doe", + "flags": ["debug", "_root"], + "publish": { + "tags": ["template", "root"], + "description": "Decky example plugin.", + "image": "https://opengraph.githubassets.com/1/SteamDeckHomebrew/PluginLoader" + } +} diff --git a/templates/decky/pnpm-lock.yaml b/templates/decky/pnpm-lock.yaml new file mode 100644 index 0000000..4b23ddd --- /dev/null +++ b/templates/decky/pnpm-lock.yaml @@ -0,0 +1,911 @@ +lockfileVersion: 5.4 + +specifiers: + '@rollup/plugin-commonjs': ^21.1.0 + '@rollup/plugin-json': ^4.1.0 + '@rollup/plugin-node-resolve': ^13.2.1 + '@rollup/plugin-replace': ^4.0.0 + '@rollup/plugin-typescript': ^8.3.2 + '@types/react': 16.14.0 + '@types/webpack': ^5.28.0 + decky-frontend-lib: ^1.0.1 + react-icons: ^4.3.1 + rollup: ^2.70.2 + rollup-plugin-import-assets: ^1.1.1 + shx: ^0.3.4 + tslib: ^2.4.0 + typescript: ^4.6.4 + +dependencies: + decky-frontend-lib: 1.0.1 + react-icons: 4.4.0 + +devDependencies: + '@rollup/plugin-commonjs': 21.1.0_rollup@2.75.6 + '@rollup/plugin-json': 4.1.0_rollup@2.75.6 + '@rollup/plugin-node-resolve': 13.3.0_rollup@2.75.6 + '@rollup/plugin-replace': 4.0.0_rollup@2.75.6 + '@rollup/plugin-typescript': 8.3.3_a4s7325ov6m337p2dvgeh54tg4 + '@types/react': 16.14.0 + '@types/webpack': 5.28.0 + rollup: 2.75.6 + rollup-plugin-import-assets: 1.1.1_rollup@2.75.6 + shx: 0.3.4 + tslib: 2.4.0 + typescript: 4.7.3 + +packages: + + /@jridgewell/gen-mapping/0.3.1: + resolution: {integrity: sha512-GcHwniMlA2z+WFPWuY8lp3fsza0I8xPFMWL5+n8LYyP6PSvPrXf4+n8stDHZY2DM0zy9sVkRDy1jDI4XGzYVqg==} + engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/set-array': 1.1.1 + '@jridgewell/sourcemap-codec': 1.4.13 + '@jridgewell/trace-mapping': 0.3.13 + dev: true + + /@jridgewell/resolve-uri/3.0.7: + resolution: {integrity: sha512-8cXDaBBHOr2pQ7j77Y6Vp5VDT2sIqWyWQ56TjEq4ih/a4iST3dItRe8Q9fp0rrIl9DoKhWQtUQz/YpOxLkXbNA==} + engines: {node: '>=6.0.0'} + dev: true + + /@jridgewell/set-array/1.1.1: + resolution: {integrity: sha512-Ct5MqZkLGEXTVmQYbGtx9SVqD2fqwvdubdps5D3djjAkgkKwT918VNOz65pEHFaYTeWcukmJmH5SwsA9Tn2ObQ==} + engines: {node: '>=6.0.0'} + dev: true + + /@jridgewell/source-map/0.3.2: + resolution: {integrity: sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==} + dependencies: + '@jridgewell/gen-mapping': 0.3.1 + '@jridgewell/trace-mapping': 0.3.13 + dev: true + + /@jridgewell/sourcemap-codec/1.4.13: + resolution: {integrity: sha512-GryiOJmNcWbovBxTfZSF71V/mXbgcV3MewDe3kIMCLyIh5e7SKAeUZs+rMnJ8jkMolZ/4/VsdBmMrw3l+VdZ3w==} + dev: true + + /@jridgewell/trace-mapping/0.3.13: + resolution: {integrity: sha512-o1xbKhp9qnIAoHJSWd6KlCZfqslL4valSF81H8ImioOAxluWYWOpWkpyktY2vnt4tbrX9XYaxovq6cgowaJp2w==} + dependencies: + '@jridgewell/resolve-uri': 3.0.7 + '@jridgewell/sourcemap-codec': 1.4.13 + dev: true + + /@rollup/plugin-commonjs/21.1.0_rollup@2.75.6: + resolution: {integrity: sha512-6ZtHx3VHIp2ReNNDxHjuUml6ur+WcQ28N1yHgCQwsbNkQg2suhxGMDQGJOn/KuDxKtd1xuZP5xSTwBA4GQ8hbA==} + engines: {node: '>= 8.0.0'} + peerDependencies: + rollup: ^2.38.3 + dependencies: + '@rollup/pluginutils': 3.1.0_rollup@2.75.6 + commondir: 1.0.1 + estree-walker: 2.0.2 + glob: 7.2.3 + is-reference: 1.2.1 + magic-string: 0.25.9 + resolve: 1.22.0 + rollup: 2.75.6 + dev: true + + /@rollup/plugin-json/4.1.0_rollup@2.75.6: + resolution: {integrity: sha512-yfLbTdNS6amI/2OpmbiBoW12vngr5NW2jCJVZSBEz+H5KfUJZ2M7sDjk0U6GOOdCWFVScShte29o9NezJ53TPw==} + peerDependencies: + rollup: ^1.20.0 || ^2.0.0 + dependencies: + '@rollup/pluginutils': 3.1.0_rollup@2.75.6 + rollup: 2.75.6 + dev: true + + /@rollup/plugin-node-resolve/13.3.0_rollup@2.75.6: + resolution: {integrity: sha512-Lus8rbUo1eEcnS4yTFKLZrVumLPY+YayBdWXgFSHYhTT2iJbMhoaaBL3xl5NCdeRytErGr8tZ0L71BMRmnlwSw==} + engines: {node: '>= 10.0.0'} + peerDependencies: + rollup: ^2.42.0 + dependencies: + '@rollup/pluginutils': 3.1.0_rollup@2.75.6 + '@types/resolve': 1.17.1 + deepmerge: 4.2.2 + is-builtin-module: 3.1.0 + is-module: 1.0.0 + resolve: 1.22.0 + rollup: 2.75.6 + dev: true + + /@rollup/plugin-replace/4.0.0_rollup@2.75.6: + resolution: {integrity: sha512-+rumQFiaNac9y64OHtkHGmdjm7us9bo1PlbgQfdihQtuNxzjpaB064HbRnewUOggLQxVCCyINfStkgmBeQpv1g==} + peerDependencies: + rollup: ^1.20.0 || ^2.0.0 + dependencies: + '@rollup/pluginutils': 3.1.0_rollup@2.75.6 + magic-string: 0.25.9 + rollup: 2.75.6 + dev: true + + /@rollup/plugin-typescript/8.3.3_a4s7325ov6m337p2dvgeh54tg4: + resolution: {integrity: sha512-55L9SyiYu3r/JtqdjhwcwaECXP7JeJ9h1Sg1VWRJKIutla2MdZQodTgcCNybXLMCnqpNLEhS2vGENww98L1npg==} + engines: {node: '>=8.0.0'} + peerDependencies: + rollup: ^2.14.0 + tslib: '*' + typescript: '>=3.7.0' + peerDependenciesMeta: + tslib: + optional: true + dependencies: + '@rollup/pluginutils': 3.1.0_rollup@2.75.6 + resolve: 1.22.0 + rollup: 2.75.6 + tslib: 2.4.0 + typescript: 4.7.3 + dev: true + + /@rollup/pluginutils/3.1.0_rollup@2.75.6: + resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==} + engines: {node: '>= 8.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0 + dependencies: + '@types/estree': 0.0.39 + estree-walker: 1.0.1 + picomatch: 2.3.1 + rollup: 2.75.6 + dev: true + + /@types/eslint-scope/3.7.3: + resolution: {integrity: sha512-PB3ldyrcnAicT35TWPs5IcwKD8S333HMaa2VVv4+wdvebJkjWuW/xESoB8IwRcog8HYVYamb1g/R31Qv5Bx03g==} + dependencies: + '@types/eslint': 8.4.3 + '@types/estree': 0.0.51 + dev: true + + /@types/eslint/8.4.3: + resolution: {integrity: sha512-YP1S7YJRMPs+7KZKDb9G63n8YejIwW9BALq7a5j2+H4yl6iOv9CB29edho+cuFRrvmJbbaH2yiVChKLJVysDGw==} + dependencies: + '@types/estree': 0.0.51 + '@types/json-schema': 7.0.11 + dev: true + + /@types/estree/0.0.39: + resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==} + dev: true + + /@types/estree/0.0.51: + resolution: {integrity: sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==} + dev: true + + /@types/json-schema/7.0.11: + resolution: {integrity: sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==} + dev: true + + /@types/node/17.0.42: + resolution: {integrity: sha512-Q5BPGyGKcvQgAMbsr7qEGN/kIPN6zZecYYABeTDBizOsau+2NMdSVTar9UQw21A2+JyA2KRNDYaYrPB0Rpk2oQ==} + dev: true + + /@types/prop-types/15.7.5: + resolution: {integrity: sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w==} + dev: true + + /@types/react/16.14.0: + resolution: {integrity: sha512-jJjHo1uOe+NENRIBvF46tJimUvPnmbQ41Ax0pEm7pRvhPg+wuj8VMOHHiMvaGmZRzRrCtm7KnL5OOE/6kHPK8w==} + dependencies: + '@types/prop-types': 15.7.5 + csstype: 3.1.0 + dev: true + + /@types/resolve/1.17.1: + resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==} + dependencies: + '@types/node': 17.0.42 + dev: true + + /@types/webpack/5.28.0: + resolution: {integrity: sha512-8cP0CzcxUiFuA9xGJkfeVpqmWTk9nx6CWwamRGCj95ph1SmlRRk9KlCZ6avhCbZd4L68LvYT6l1kpdEnQXrF8w==} + dependencies: + '@types/node': 17.0.42 + tapable: 2.2.1 + webpack: 5.73.0 + transitivePeerDependencies: + - '@swc/core' + - esbuild + - uglify-js + - webpack-cli + dev: true + + /@webassemblyjs/ast/1.11.1: + resolution: {integrity: sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==} + dependencies: + '@webassemblyjs/helper-numbers': 1.11.1 + '@webassemblyjs/helper-wasm-bytecode': 1.11.1 + dev: true + + /@webassemblyjs/floating-point-hex-parser/1.11.1: + resolution: {integrity: sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==} + dev: true + + /@webassemblyjs/helper-api-error/1.11.1: + resolution: {integrity: sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==} + dev: true + + /@webassemblyjs/helper-buffer/1.11.1: + resolution: {integrity: sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==} + dev: true + + /@webassemblyjs/helper-numbers/1.11.1: + resolution: {integrity: sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==} + dependencies: + '@webassemblyjs/floating-point-hex-parser': 1.11.1 + '@webassemblyjs/helper-api-error': 1.11.1 + '@xtuc/long': 4.2.2 + dev: true + + /@webassemblyjs/helper-wasm-bytecode/1.11.1: + resolution: {integrity: sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==} + dev: true + + /@webassemblyjs/helper-wasm-section/1.11.1: + resolution: {integrity: sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==} + dependencies: + '@webassemblyjs/ast': 1.11.1 + '@webassemblyjs/helper-buffer': 1.11.1 + '@webassemblyjs/helper-wasm-bytecode': 1.11.1 + '@webassemblyjs/wasm-gen': 1.11.1 + dev: true + + /@webassemblyjs/ieee754/1.11.1: + resolution: {integrity: sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==} + dependencies: + '@xtuc/ieee754': 1.2.0 + dev: true + + /@webassemblyjs/leb128/1.11.1: + resolution: {integrity: sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==} + dependencies: + '@xtuc/long': 4.2.2 + dev: true + + /@webassemblyjs/utf8/1.11.1: + resolution: {integrity: sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==} + dev: true + + /@webassemblyjs/wasm-edit/1.11.1: + resolution: {integrity: sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==} + dependencies: + '@webassemblyjs/ast': 1.11.1 + '@webassemblyjs/helper-buffer': 1.11.1 + '@webassemblyjs/helper-wasm-bytecode': 1.11.1 + '@webassemblyjs/helper-wasm-section': 1.11.1 + '@webassemblyjs/wasm-gen': 1.11.1 + '@webassemblyjs/wasm-opt': 1.11.1 + '@webassemblyjs/wasm-parser': 1.11.1 + '@webassemblyjs/wast-printer': 1.11.1 + dev: true + + /@webassemblyjs/wasm-gen/1.11.1: + resolution: {integrity: sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==} + dependencies: + '@webassemblyjs/ast': 1.11.1 + '@webassemblyjs/helper-wasm-bytecode': 1.11.1 + '@webassemblyjs/ieee754': 1.11.1 + '@webassemblyjs/leb128': 1.11.1 + '@webassemblyjs/utf8': 1.11.1 + dev: true + + /@webassemblyjs/wasm-opt/1.11.1: + resolution: {integrity: sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==} + dependencies: + '@webassemblyjs/ast': 1.11.1 + '@webassemblyjs/helper-buffer': 1.11.1 + '@webassemblyjs/wasm-gen': 1.11.1 + '@webassemblyjs/wasm-parser': 1.11.1 + dev: true + + /@webassemblyjs/wasm-parser/1.11.1: + resolution: {integrity: sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==} + dependencies: + '@webassemblyjs/ast': 1.11.1 + '@webassemblyjs/helper-api-error': 1.11.1 + '@webassemblyjs/helper-wasm-bytecode': 1.11.1 + '@webassemblyjs/ieee754': 1.11.1 + '@webassemblyjs/leb128': 1.11.1 + '@webassemblyjs/utf8': 1.11.1 + dev: true + + /@webassemblyjs/wast-printer/1.11.1: + resolution: {integrity: sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==} + dependencies: + '@webassemblyjs/ast': 1.11.1 + '@xtuc/long': 4.2.2 + dev: true + + /@xtuc/ieee754/1.2.0: + resolution: {integrity: sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==} + dev: true + + /@xtuc/long/4.2.2: + resolution: {integrity: sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==} + dev: true + + /acorn-import-assertions/1.8.0_acorn@8.7.1: + resolution: {integrity: sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==} + peerDependencies: + acorn: ^8 + dependencies: + acorn: 8.7.1 + dev: true + + /acorn/8.7.1: + resolution: {integrity: sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==} + engines: {node: '>=0.4.0'} + hasBin: true + dev: true + + /ajv-keywords/3.5.2_ajv@6.12.6: + resolution: {integrity: sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==} + peerDependencies: + ajv: ^6.9.1 + dependencies: + ajv: 6.12.6 + dev: true + + /ajv/6.12.6: + resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} + dependencies: + fast-deep-equal: 3.1.3 + fast-json-stable-stringify: 2.1.0 + json-schema-traverse: 0.4.1 + uri-js: 4.4.1 + dev: true + + /balanced-match/1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + dev: true + + /brace-expansion/1.1.11: + resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} + dependencies: + balanced-match: 1.0.2 + concat-map: 0.0.1 + dev: true + + /browserslist/4.20.4: + resolution: {integrity: sha512-ok1d+1WpnU24XYN7oC3QWgTyMhY/avPJ/r9T00xxvUOIparA/gc+UPUMaod3i+G6s+nI2nUb9xZ5k794uIwShw==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true + dependencies: + caniuse-lite: 1.0.30001352 + electron-to-chromium: 1.4.154 + escalade: 3.1.1 + node-releases: 2.0.5 + picocolors: 1.0.0 + dev: true + + /buffer-from/1.1.2: + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + dev: true + + /builtin-modules/3.3.0: + resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} + engines: {node: '>=6'} + dev: true + + /caniuse-lite/1.0.30001352: + resolution: {integrity: sha512-GUgH8w6YergqPQDGWhJGt8GDRnY0L/iJVQcU3eJ46GYf52R8tk0Wxp0PymuFVZboJYXGiCqwozAYZNRjVj6IcA==} + dev: true + + /chrome-trace-event/1.0.3: + resolution: {integrity: sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==} + engines: {node: '>=6.0'} + dev: true + + /commander/2.20.3: + resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==} + dev: true + + /commondir/1.0.1: + resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==} + dev: true + + /concat-map/0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + dev: true + + /csstype/3.1.0: + resolution: {integrity: sha512-uX1KG+x9h5hIJsaKR9xHUeUraxf8IODOwq9JLNPq6BwB04a/xgpq3rcx47l5BZu5zBPlgD342tdke3Hom/nJRA==} + dev: true + + /decky-frontend-lib/1.0.1: + resolution: {integrity: sha512-SgIPoB3IcWbzVRlXvs8JfhwrMphHYa7O/Ek2mh+rC0WTVT3TI2qGJ5+OoV16mw5kGY0DMu1ikcZC6ib1lh2zKQ==} + dev: false + + /deepmerge/4.2.2: + resolution: {integrity: sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==} + engines: {node: '>=0.10.0'} + dev: true + + /electron-to-chromium/1.4.154: + resolution: {integrity: sha512-GbV9djOkrnj6xmW+YYVVEI3VCQnJ0pnSTu7TW2JyjKd5cakoiSaG5R4RbEtfaD92GsY10DzbU3GYRe+IOA9kqA==} + dev: true + + /enhanced-resolve/5.9.3: + resolution: {integrity: sha512-Bq9VSor+kjvW3f9/MiiR4eE3XYgOl7/rS8lnSxbRbF3kS0B2r+Y9w5krBWxZgDxASVZbdYrn5wT4j/Wb0J9qow==} + engines: {node: '>=10.13.0'} + dependencies: + graceful-fs: 4.2.10 + tapable: 2.2.1 + dev: true + + /es-module-lexer/0.9.3: + resolution: {integrity: sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==} + dev: true + + /escalade/3.1.1: + resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==} + engines: {node: '>=6'} + dev: true + + /eslint-scope/5.1.1: + resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==} + engines: {node: '>=8.0.0'} + dependencies: + esrecurse: 4.3.0 + estraverse: 4.3.0 + dev: true + + /esrecurse/4.3.0: + resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} + engines: {node: '>=4.0'} + dependencies: + estraverse: 5.3.0 + dev: true + + /estraverse/4.3.0: + resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==} + engines: {node: '>=4.0'} + dev: true + + /estraverse/5.3.0: + resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} + engines: {node: '>=4.0'} + dev: true + + /estree-walker/0.6.1: + resolution: {integrity: sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==} + dev: true + + /estree-walker/1.0.1: + resolution: {integrity: sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==} + dev: true + + /estree-walker/2.0.2: + resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==} + dev: true + + /events/3.3.0: + resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} + engines: {node: '>=0.8.x'} + dev: true + + /fast-deep-equal/3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + dev: true + + /fast-json-stable-stringify/2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + dev: true + + /fs.realpath/1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + dev: true + + /fsevents/2.3.2: + resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + requiresBuild: true + dev: true + optional: true + + /function-bind/1.1.1: + resolution: {integrity: sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==} + dev: true + + /glob-to-regexp/0.4.1: + resolution: {integrity: sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==} + dev: true + + /glob/7.2.3: + resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + dependencies: + fs.realpath: 1.0.0 + inflight: 1.0.6 + inherits: 2.0.4 + minimatch: 3.1.2 + once: 1.4.0 + path-is-absolute: 1.0.1 + dev: true + + /graceful-fs/4.2.10: + resolution: {integrity: sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==} + dev: true + + /has-flag/4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} + dev: true + + /has/1.0.3: + resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==} + engines: {node: '>= 0.4.0'} + dependencies: + function-bind: 1.1.1 + dev: true + + /inflight/1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + dependencies: + once: 1.4.0 + wrappy: 1.0.2 + dev: true + + /inherits/2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + dev: true + + /interpret/1.4.0: + resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==} + engines: {node: '>= 0.10'} + dev: true + + /is-builtin-module/3.1.0: + resolution: {integrity: sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==} + engines: {node: '>=6'} + dependencies: + builtin-modules: 3.3.0 + dev: true + + /is-core-module/2.9.0: + resolution: {integrity: sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==} + dependencies: + has: 1.0.3 + dev: true + + /is-module/1.0.0: + resolution: {integrity: sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==} + dev: true + + /is-reference/1.2.1: + resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==} + dependencies: + '@types/estree': 0.0.51 + dev: true + + /jest-worker/27.5.1: + resolution: {integrity: sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==} + engines: {node: '>= 10.13.0'} + dependencies: + '@types/node': 17.0.42 + merge-stream: 2.0.0 + supports-color: 8.1.1 + dev: true + + /json-parse-even-better-errors/2.3.1: + resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + dev: true + + /json-schema-traverse/0.4.1: + resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + dev: true + + /loader-runner/4.3.0: + resolution: {integrity: sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==} + engines: {node: '>=6.11.5'} + dev: true + + /magic-string/0.25.9: + resolution: {integrity: sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==} + dependencies: + sourcemap-codec: 1.4.8 + dev: true + + /merge-stream/2.0.0: + resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} + dev: true + + /mime-db/1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} + dev: true + + /mime-types/2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} + dependencies: + mime-db: 1.52.0 + dev: true + + /minimatch/3.1.2: + resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + dependencies: + brace-expansion: 1.1.11 + dev: true + + /minimist/1.2.6: + resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==} + dev: true + + /neo-async/2.6.2: + resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==} + dev: true + + /node-releases/2.0.5: + resolution: {integrity: sha512-U9h1NLROZTq9uE1SNffn6WuPDg8icmi3ns4rEl/oTfIle4iLjTliCzgTsbaIFMq/Xn078/lfY/BL0GWZ+psK4Q==} + dev: true + + /once/1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + dependencies: + wrappy: 1.0.2 + dev: true + + /path-is-absolute/1.0.1: + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} + dev: true + + /path-parse/1.0.7: + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + dev: true + + /picocolors/1.0.0: + resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==} + dev: true + + /picomatch/2.3.1: + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} + dev: true + + /punycode/2.1.1: + resolution: {integrity: sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==} + engines: {node: '>=6'} + dev: true + + /randombytes/2.1.0: + resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} + dependencies: + safe-buffer: 5.2.1 + dev: true + + /react-icons/4.4.0: + resolution: {integrity: sha512-fSbvHeVYo/B5/L4VhB7sBA1i2tS8MkT0Hb9t2H1AVPkwGfVHLJCqyr2Py9dKMxsyM63Eng1GkdZfbWj+Fmv8Rg==} + peerDependencies: + react: '*' + peerDependenciesMeta: + react: + optional: true + dev: false + + /rechoir/0.6.2: + resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==} + engines: {node: '>= 0.10'} + dependencies: + resolve: 1.22.0 + dev: true + + /resolve/1.22.0: + resolution: {integrity: sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==} + hasBin: true + dependencies: + is-core-module: 2.9.0 + path-parse: 1.0.7 + supports-preserve-symlinks-flag: 1.0.0 + dev: true + + /rollup-plugin-import-assets/1.1.1_rollup@2.75.6: + resolution: {integrity: sha512-u5zJwOjguTf2N+wETq2weNKGvNkuVc1UX/fPgg215p5xPvGOaI6/BTc024E9brvFjSQTfIYqgvwogQdipknu1g==} + peerDependencies: + rollup: '>=1.9.0' + dependencies: + rollup: 2.75.6 + rollup-pluginutils: 2.8.2 + url-join: 4.0.1 + dev: true + + /rollup-pluginutils/2.8.2: + resolution: {integrity: sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==} + dependencies: + estree-walker: 0.6.1 + dev: true + + /rollup/2.75.6: + resolution: {integrity: sha512-OEf0TgpC9vU6WGROJIk1JA3LR5vk/yvqlzxqdrE2CzzXnqKXNzbAwlWUXis8RS3ZPe7LAq+YUxsRa0l3r27MLA==} + engines: {node: '>=10.0.0'} + hasBin: true + optionalDependencies: + fsevents: 2.3.2 + dev: true + + /safe-buffer/5.2.1: + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + dev: true + + /schema-utils/3.1.1: + resolution: {integrity: sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==} + engines: {node: '>= 10.13.0'} + dependencies: + '@types/json-schema': 7.0.11 + ajv: 6.12.6 + ajv-keywords: 3.5.2_ajv@6.12.6 + dev: true + + /serialize-javascript/6.0.0: + resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==} + dependencies: + randombytes: 2.1.0 + dev: true + + /shelljs/0.8.5: + resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==} + engines: {node: '>=4'} + hasBin: true + dependencies: + glob: 7.2.3 + interpret: 1.4.0 + rechoir: 0.6.2 + dev: true + + /shx/0.3.4: + resolution: {integrity: sha512-N6A9MLVqjxZYcVn8hLmtneQWIJtp8IKzMP4eMnx+nqkvXoqinUPCbUFLp2UcWTEIUONhlk0ewxr/jaVGlc+J+g==} + engines: {node: '>=6'} + hasBin: true + dependencies: + minimist: 1.2.6 + shelljs: 0.8.5 + dev: true + + /source-map-support/0.5.21: + resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} + dependencies: + buffer-from: 1.1.2 + source-map: 0.6.1 + dev: true + + /source-map/0.6.1: + resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + engines: {node: '>=0.10.0'} + dev: true + + /sourcemap-codec/1.4.8: + resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==} + dev: true + + /supports-color/8.1.1: + resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} + engines: {node: '>=10'} + dependencies: + has-flag: 4.0.0 + dev: true + + /supports-preserve-symlinks-flag/1.0.0: + resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} + engines: {node: '>= 0.4'} + dev: true + + /tapable/2.2.1: + resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==} + engines: {node: '>=6'} + dev: true + + /terser-webpack-plugin/5.3.3_webpack@5.73.0: + resolution: {integrity: sha512-Fx60G5HNYknNTNQnzQ1VePRuu89ZVYWfjRAeT5rITuCY/1b08s49e5kSQwHDirKZWuoKOBRFS98EUUoZ9kLEwQ==} + engines: {node: '>= 10.13.0'} + peerDependencies: + '@swc/core': '*' + esbuild: '*' + uglify-js: '*' + webpack: ^5.1.0 + peerDependenciesMeta: + '@swc/core': + optional: true + esbuild: + optional: true + uglify-js: + optional: true + dependencies: + '@jridgewell/trace-mapping': 0.3.13 + jest-worker: 27.5.1 + schema-utils: 3.1.1 + serialize-javascript: 6.0.0 + terser: 5.14.1 + webpack: 5.73.0 + dev: true + + /terser/5.14.1: + resolution: {integrity: sha512-+ahUAE+iheqBTDxXhTisdA8hgvbEG1hHOQ9xmNjeUJSoi6DU/gMrKNcfZjHkyY6Alnuyc+ikYJaxxfHkT3+WuQ==} + engines: {node: '>=10'} + hasBin: true + dependencies: + '@jridgewell/source-map': 0.3.2 + acorn: 8.7.1 + commander: 2.20.3 + source-map-support: 0.5.21 + dev: true + + /tslib/2.4.0: + resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==} + dev: true + + /typescript/4.7.3: + resolution: {integrity: sha512-WOkT3XYvrpXx4vMMqlD+8R8R37fZkjyLGlxavMc4iB8lrl8L0DeTcHbYgw/v0N/z9wAFsgBhcsF0ruoySS22mA==} + engines: {node: '>=4.2.0'} + hasBin: true + dev: true + + /uri-js/4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + dependencies: + punycode: 2.1.1 + dev: true + + /url-join/4.0.1: + resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==} + dev: true + + /watchpack/2.4.0: + resolution: {integrity: sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==} + engines: {node: '>=10.13.0'} + dependencies: + glob-to-regexp: 0.4.1 + graceful-fs: 4.2.10 + dev: true + + /webpack-sources/3.2.3: + resolution: {integrity: sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==} + engines: {node: '>=10.13.0'} + dev: true + + /webpack/5.73.0: + resolution: {integrity: sha512-svjudQRPPa0YiOYa2lM/Gacw0r6PvxptHj4FuEKQ2kX05ZLkjbVc5MnPs6its5j7IZljnIqSVo/OsY2X0IpHGA==} + engines: {node: '>=10.13.0'} + hasBin: true + peerDependencies: + webpack-cli: '*' + peerDependenciesMeta: + webpack-cli: + optional: true + dependencies: + '@types/eslint-scope': 3.7.3 + '@types/estree': 0.0.51 + '@webassemblyjs/ast': 1.11.1 + '@webassemblyjs/wasm-edit': 1.11.1 + '@webassemblyjs/wasm-parser': 1.11.1 + acorn: 8.7.1 + acorn-import-assertions: 1.8.0_acorn@8.7.1 + browserslist: 4.20.4 + chrome-trace-event: 1.0.3 + enhanced-resolve: 5.9.3 + es-module-lexer: 0.9.3 + eslint-scope: 5.1.1 + events: 3.3.0 + glob-to-regexp: 0.4.1 + graceful-fs: 4.2.10 + json-parse-even-better-errors: 2.3.1 + loader-runner: 4.3.0 + mime-types: 2.1.35 + neo-async: 2.6.2 + schema-utils: 3.1.1 + tapable: 2.2.1 + terser-webpack-plugin: 5.3.3_webpack@5.73.0 + watchpack: 2.4.0 + webpack-sources: 3.2.3 + transitivePeerDependencies: + - '@swc/core' + - esbuild + - uglify-js + dev: true + + /wrappy/1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + dev: true diff --git a/templates/decky/rollup.config.js b/templates/decky/rollup.config.js new file mode 100644 index 0000000..8717908 --- /dev/null +++ b/templates/decky/rollup.config.js @@ -0,0 +1,37 @@ +import commonjs from '@rollup/plugin-commonjs'; +import json from '@rollup/plugin-json'; +import { nodeResolve } from '@rollup/plugin-node-resolve'; +import replace from '@rollup/plugin-replace'; +import typescript from '@rollup/plugin-typescript'; +import { defineConfig } from 'rollup'; +import importAssets from 'rollup-plugin-import-assets'; + +import { name } from "./plugin.json"; + +export default defineConfig({ + input: './src/index.tsx', + plugins: [ + commonjs(), + nodeResolve(), + typescript(), + json(), + replace({ + preventAssignment: false, + 'process.env.NODE_ENV': JSON.stringify('production'), + }), + importAssets({ + publicPath: `http://127.0.0.1:1337/plugins/${name}/` + }) + ], + context: 'window', + external: ['react', 'react-dom'], + output: { + file: 'dist/index.js', + globals: { + react: 'SP_REACT', + 'react-dom': 'SP_REACTDOM', + }, + format: 'iife', + exports: 'default', + }, +}); diff --git a/templates/decky/src/index.tsx b/templates/decky/src/index.tsx new file mode 100755 index 0000000..e36d6dc --- /dev/null +++ b/templates/decky/src/index.tsx @@ -0,0 +1,123 @@ +import { + ButtonItem, + definePlugin, + DialogButton, + Menu, + MenuItem, + PanelSection, + PanelSectionRow, + Router, + ServerAPI, + showContextMenu, + staticClasses, +} from "decky-frontend-lib"; +import { VFC } from "react"; +import { FaShip } from "react-icons/fa"; + +import logo from "../assets/logo.png"; + +import {init_usdpl, target, init_embedded, call_backend} from "usdpl-front"; + +const USDPL_PORT: number = 54321; + +// interface AddMethodArgs { +// left: number; +// right: number; +// } + +const Content: VFC<{ serverAPI: ServerAPI }> = ({}) => { + // const [result, setResult] = useState(); + + // const onClick = async () => { + // const result = await serverAPI.callPluginMethod( + // "add", + // { + // left: 2, + // right: 2, + // } + // ); + // if (result.success) { + // setResult(result.result); + // } + // }; + + // call hello callback on backend + (async () => { + let response = await call_backend("hello", []); + console.log("Backend says:", response); + })(); + + return ( + + + + showContextMenu( + {}}> + {}}>Item #1 + {}}>Item #2 + {}}>Item #3 + , + e.currentTarget ?? window + ) + } + > + Server says yolo + + + + +
+ +
+ + + + { + Router.CloseSideMenus(); + Router.Navigate("/decky-plugin-test"); + }} + > + Router + + + + ); +}; + +const DeckyPluginRouterTest: VFC = () => { + return ( +
+ Hello World! + Router.NavigateToStore()}> + Go to Store + +
+ ); +}; + +export default definePlugin((serverApi: ServerAPI) => { + serverApi.routerHook.addRoute("/decky-plugin-test", DeckyPluginRouterTest, { + exact: true, + }); + + // init USDPL WASM frontend + // this is required to interface with the backend + (async () => { + await init_embedded(); + init_usdpl(USDPL_PORT); + console.log("USDPL started for framework: " + target()); + })(); + + return { + title:
Example Plugin
, + content: , + icon: , + onDismount() { + serverApi.routerHook.removeRoute("/decky-plugin-test"); + }, + }; +}); diff --git a/templates/decky/src/types.d.ts b/templates/decky/src/types.d.ts new file mode 100644 index 0000000..dfc0472 --- /dev/null +++ b/templates/decky/src/types.d.ts @@ -0,0 +1,14 @@ +declare module "*.svg" { + const content: string; + export default content; +} + +declare module "*.png" { + const content: string; + export default content; +} + +declare module "*.jpg" { + const content: string; + export default content; +} diff --git a/templates/decky/src/usdpl-front/usdpl.d.ts b/templates/decky/src/usdpl-front/usdpl.d.ts new file mode 100644 index 0000000..da84559 --- /dev/null +++ b/templates/decky/src/usdpl-front/usdpl.d.ts @@ -0,0 +1,57 @@ +/* tslint:disable */ +/* eslint-disable */ +/** +* Initialize the front-end library +* @param {number} port +*/ +export function init_usdpl(port: number): void; +/** +* Get the targeted plugin framework, or "any" if unknown +* @returns {string} +*/ +export function target(): string; +/** +* Call a function on the back-end. +* Returns null (None) if this fails for any reason. +* @param {string} name +* @param {any[]} parameters +* @returns {Promise} +*/ +export function call_backend(name: string, parameters: any[]): Promise; +/** +*/ +export class UsdplContext { + free(): void; +} + +export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module; + +export interface InitOutput { + readonly memory: WebAssembly.Memory; + readonly __wbg_usdplcontext_free: (a: number) => void; + readonly init_usdpl: (a: number) => void; + readonly target: (a: number) => void; + readonly call_backend: (a: number, b: number, c: number, d: number) => number; + readonly __wbindgen_malloc: (a: number) => number; + readonly __wbindgen_realloc: (a: number, b: number, c: number) => number; + readonly __wbindgen_export_2: WebAssembly.Table; + readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h16ac289f583b8044: (a: number, b: number, c: number) => void; + readonly __wbindgen_add_to_stack_pointer: (a: number) => number; + readonly __wbindgen_free: (a: number, b: number) => void; + readonly __wbindgen_exn_store: (a: number) => void; + readonly wasm_bindgen__convert__closures__invoke2_mut__ha1c5a356ae6a22de: (a: number, b: number, c: number, d: number) => void; +} + +/** +* If `module_or_path` is {RequestInfo} or {URL}, makes a request and +* for everything else, calls `WebAssembly.instantiate` directly. +* +* @param {InitInput | Promise} module_or_path +* +* @returns {Promise} +*/ +export default function init (module_or_path?: InitInput | Promise): Promise; + + +// USDPL customization +export function init_embedded(); diff --git a/templates/decky/src/usdpl-front/usdpl.js b/templates/decky/src/usdpl-front/usdpl.js new file mode 100644 index 0000000..16b3303 --- /dev/null +++ b/templates/decky/src/usdpl-front/usdpl.js @@ -0,0 +1,589 @@ + +let wasm; + +const heap = new Array(32).fill(undefined); + +heap.push(undefined, null, true, false); + +function getObject(idx) { return heap[idx]; } + +let WASM_VECTOR_LEN = 0; + +let cachegetUint8Memory0 = null; +function getUint8Memory0() { + if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) { + cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachegetUint8Memory0; +} + +const cachedTextEncoder = new TextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length); + getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len); + + const mem = getUint8Memory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3); + const view = getUint8Memory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +let cachegetInt32Memory0 = null; +function getInt32Memory0() { + if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) { + cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer); + } + return cachegetInt32Memory0; +} + +const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +function getStringFromWasm0(ptr, len) { + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} + +let heap_next = heap.length; + +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + +function dropObject(idx) { + if (idx < 36) return; + heap[idx] = heap_next; + heap_next = idx; +} + +function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; +} + +let cachegetFloat64Memory0 = null; +function getFloat64Memory0() { + if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) { + cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer); + } + return cachegetFloat64Memory0; +} + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +function makeMutClosure(arg0, arg1, dtor, f) { + const state = { a: arg0, b: arg1, cnt: 1, dtor }; + const real = (...args) => { + // First up with a closure we increment the internal reference + // count. This ensures that the Rust closure environment won't + // be deallocated while we're invoking it. + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + if (--state.cnt === 0) { + wasm.__wbindgen_export_2.get(state.dtor)(a, state.b); + + } else { + state.a = a; + } + } + }; + real.original = state; + + return real; +} +function __wbg_adapter_28(arg0, arg1, arg2) { + wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h16ac289f583b8044(arg0, arg1, addHeapObject(arg2)); +} + +/** +* Initialize the front-end library +* @param {number} port +*/ +export function init_usdpl(port) { + wasm.init_usdpl(port); +} + +/** +* Get the targeted plugin framework, or "any" if unknown +* @returns {string} +*/ +export function target() { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.target(retptr); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + return getStringFromWasm0(r0, r1); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + wasm.__wbindgen_free(r0, r1); + } +} + +let cachegetUint32Memory0 = null; +function getUint32Memory0() { + if (cachegetUint32Memory0 === null || cachegetUint32Memory0.buffer !== wasm.memory.buffer) { + cachegetUint32Memory0 = new Uint32Array(wasm.memory.buffer); + } + return cachegetUint32Memory0; +} + +function passArrayJsValueToWasm0(array, malloc) { + const ptr = malloc(array.length * 4); + const mem = getUint32Memory0(); + for (let i = 0; i < array.length; i++) { + mem[ptr / 4 + i] = addHeapObject(array[i]); + } + WASM_VECTOR_LEN = array.length; + return ptr; +} +/** +* Call a function on the back-end. +* Returns null (None) if this fails for any reason. +* @param {string} name +* @param {any[]} parameters +* @returns {Promise} +*/ +export function call_backend(name, parameters) { + const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArrayJsValueToWasm0(parameters, wasm.__wbindgen_malloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.call_backend(ptr0, len0, ptr1, len1); + return takeObject(ret); +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + wasm.__wbindgen_exn_store(addHeapObject(e)); + } +} +function __wbg_adapter_70(arg0, arg1, arg2, arg3) { + wasm.wasm_bindgen__convert__closures__invoke2_mut__ha1c5a356ae6a22de(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); +} + +/** +*/ +export class UsdplContext { + + __destroy_into_raw() { + const ptr = this.ptr; + this.ptr = 0; + + return ptr; + } + + free() { + const ptr = this.__destroy_into_raw(); + wasm.__wbg_usdplcontext_free(ptr); + } +} + +async function load(module, imports) { + if (typeof Response === 'function' && module instanceof Response) { + if (typeof WebAssembly.instantiateStreaming === 'function') { + try { + return await WebAssembly.instantiateStreaming(module, imports); + + } catch (e) { + if (module.headers.get('Content-Type') != 'application/wasm') { + console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); + + } else { + throw e; + } + } + } + + const bytes = await module.arrayBuffer(); + return await WebAssembly.instantiate(bytes, imports); + + } else { + const instance = await WebAssembly.instantiate(module, imports); + + if (instance instanceof WebAssembly.Instance) { + return { instance, module }; + + } else { + return instance; + } + } +} + +async function init(input) { + if (typeof input === 'undefined') { + input = new URL('usdpl_bg.wasm', import.meta.url); + } + const imports = {}; + imports.wbg = {}; + imports.wbg.__wbindgen_string_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbindgen_string_new = function(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_number_new = function(arg0) { + const ret = arg0; + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); + }; + imports.wbg.__wbindgen_boolean_get = function(arg0) { + const v = getObject(arg0); + const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2; + return ret; + }; + imports.wbg.__wbindgen_number_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'number' ? obj : undefined; + getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret; + getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret); + }; + imports.wbg.__wbindgen_is_null = function(arg0) { + const ret = getObject(arg0) === null; + return ret; + }; + imports.wbg.__wbindgen_is_undefined = function(arg0) { + const ret = getObject(arg0) === undefined; + return ret; + }; + imports.wbg.__wbg_log_38227cc3931a246c = function(arg0, arg1) { + console.log(getStringFromWasm0(arg0, arg1)); + }; + imports.wbg.__wbg_error_5cf0317ed457a80c = function(arg0, arg1) { + console.error(getStringFromWasm0(arg0, arg1)); + }; + imports.wbg.__wbg_new_693216e109162396 = function() { + const ret = new Error(); + return addHeapObject(ret); + }; + imports.wbg.__wbg_stack_0ddaca5d1abfb52f = function(arg0, arg1) { + const ret = getObject(arg1).stack; + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbg_error_09919627ac0992f5 = function(arg0, arg1) { + try { + console.error(getStringFromWasm0(arg0, arg1)); + } finally { + wasm.__wbindgen_free(arg0, arg1); + } + }; + imports.wbg.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_headers_0a71906114661592 = function(arg0) { + const ret = getObject(arg0).headers; + return addHeapObject(ret); + }; + imports.wbg.__wbg_newwithstrandinit_fd99688f189f053e = function() { return handleError(function (arg0, arg1, arg2) { + const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_set_6884dcc6cdd65022 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) { + getObject(arg0).set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4)); + }, arguments) }; + imports.wbg.__wbg_instanceof_Window_0e6c0f1096d66c3c = function(arg0) { + const ret = getObject(arg0) instanceof Window; + return ret; + }; + imports.wbg.__wbg_fetch_ef7a6623d1fcd3b8 = function(arg0, arg1) { + const ret = getObject(arg0).fetch(getObject(arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_instanceof_Response_ccfeb62399355bcd = function(arg0) { + const ret = getObject(arg0) instanceof Response; + return ret; + }; + imports.wbg.__wbg_url_06c0f822d68d195c = function(arg0, arg1) { + const ret = getObject(arg1).url; + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbg_text_2612fbe0b9d32220 = function() { return handleError(function (arg0) { + const ret = getObject(arg0).text(); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbindgen_cb_drop = function(arg0) { + const obj = takeObject(arg0).original; + if (obj.cnt-- == 1) { + obj.a = 0; + return true; + } + const ret = false; + return ret; + }; + imports.wbg.__wbg_newnoargs_e23b458e372830de = function(arg0, arg1) { + const ret = new Function(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_call_ae78342adc33730a = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).call(getObject(arg1)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_new_36359baae5a47e27 = function() { + const ret = new Object(); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_is_string = function(arg0) { + const ret = typeof(getObject(arg0)) === 'string'; + return ret; + }; + imports.wbg.__wbg_self_99737b4dcdf6f0d8 = function() { return handleError(function () { + const ret = self.self; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_window_9b61fbbf3564c4fb = function() { return handleError(function () { + const ret = window.window; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_globalThis_8e275ef40caea3a3 = function() { return handleError(function () { + const ret = globalThis.globalThis; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_global_5de1e0f82bddcd27 = function() { return handleError(function () { + const ret = global.global; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_newwithlength_e80fb11cf19c1628 = function(arg0) { + const ret = new Array(arg0 >>> 0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_set_561aac756158708c = function(arg0, arg1, arg2) { + getObject(arg0)[arg1 >>> 0] = takeObject(arg2); + }; + imports.wbg.__wbg_call_3ed288a247f13ea5 = function() { return handleError(function (arg0, arg1, arg2) { + const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_new_37705eed627d5ed9 = function(arg0, arg1) { + try { + var state0 = {a: arg0, b: arg1}; + var cb0 = (arg0, arg1) => { + const a = state0.a; + state0.a = 0; + try { + return __wbg_adapter_70(a, state0.b, arg0, arg1); + } finally { + state0.a = a; + } + }; + const ret = new Promise(cb0); + return addHeapObject(ret); + } finally { + state0.a = state0.b = 0; + } + }; + imports.wbg.__wbg_resolve_a9a87bdd64e9e62c = function(arg0) { + const ret = Promise.resolve(getObject(arg0)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_then_ce526c837d07b68f = function(arg0, arg1) { + const ret = getObject(arg0).then(getObject(arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_then_842e65b843962f56 = function(arg0, arg1, arg2) { + const ret = getObject(arg0).then(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_set_93b1c87ee2af852e = function() { return handleError(function (arg0, arg1, arg2) { + const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2)); + return ret; + }, arguments) }; + imports.wbg.__wbg_parse_8217e7299bf72f3d = function() { return handleError(function (arg0, arg1) { + const ret = JSON.parse(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_stringify_c760003feffcc1f2 = function() { return handleError(function (arg0) { + const ret = JSON.stringify(getObject(arg0)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbindgen_debug_string = function(arg0, arg1) { + const ret = debugString(getObject(arg1)); + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); + }; + imports.wbg.__wbindgen_closure_wrapper646 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 66, __wbg_adapter_28); + return addHeapObject(ret); + }; + + if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) { + input = fetch(input); + } + + + + const { instance, module } = await load(await input, imports); + + wasm = instance.exports; + init.__wbindgen_wasm_module = module; + + return wasm; +} + +export default init; + + + +// USDPL customization +const encoded = "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"; + +function asciiToBinary(str) { + if (typeof atob === 'function') { + return atob(str) + } else { + return new Buffer(str, 'base64').toString('binary'); + } +} + +function decode() { + var binaryString = asciiToBinary(encoded); + var bytes = new Uint8Array(binaryString.length); + for (var i = 0; i < binaryString.length; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return (async function() {return new Response(bytes.buffer);})(); +} + +export function init_embedded() { + return init(decode()) +} diff --git a/templates/decky/src/usdpl-front/usdpl_bg.wasm b/templates/decky/src/usdpl-front/usdpl_bg.wasm new file mode 100644 index 0000000..bc48dc8 Binary files /dev/null and b/templates/decky/src/usdpl-front/usdpl_bg.wasm differ diff --git a/templates/decky/src/usdpl-front/usdpl_bg.wasm.d.ts b/templates/decky/src/usdpl-front/usdpl_bg.wasm.d.ts new file mode 100644 index 0000000..07536d4 --- /dev/null +++ b/templates/decky/src/usdpl-front/usdpl_bg.wasm.d.ts @@ -0,0 +1,15 @@ +/* tslint:disable */ +/* eslint-disable */ +export const memory: WebAssembly.Memory; +export function __wbg_usdplcontext_free(a: number): void; +export function init_usdpl(a: number): void; +export function target(a: number): void; +export function call_backend(a: number, b: number, c: number, d: number): number; +export function __wbindgen_malloc(a: number): number; +export function __wbindgen_realloc(a: number, b: number, c: number): number; +export const __wbindgen_export_2: WebAssembly.Table; +export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h16ac289f583b8044(a: number, b: number, c: number): void; +export function __wbindgen_add_to_stack_pointer(a: number): number; +export function __wbindgen_free(a: number, b: number): void; +export function __wbindgen_exn_store(a: number): void; +export function wasm_bindgen__convert__closures__invoke2_mut__ha1c5a356ae6a22de(a: number, b: number, c: number, d: number): void; diff --git a/templates/decky/src/usdpl-front/usdpl_front.d.ts b/templates/decky/src/usdpl-front/usdpl_front.d.ts new file mode 100644 index 0000000..5ca612b --- /dev/null +++ b/templates/decky/src/usdpl-front/usdpl_front.d.ts @@ -0,0 +1,60 @@ +/* tslint:disable */ +/* eslint-disable */ +/** +* Initialize the front-end library +* @param {number} port +*/ +export function init_usdpl(port: number): void; +/** +* Get the targeted plugin framework, or "any" if unknown +* @returns {string} +*/ +export function target(): string; +/** +* Call a function on the back-end. +* Returns null (None) if this fails for any reason. +* @param {string} name +* @param {any[]} parameters +* @returns {Promise} +*/ +export function call_backend(name: string, parameters: any[]): Promise; + +export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module; + +export interface InitOutput { + readonly memory: WebAssembly.Memory; + readonly init_usdpl: (a: number) => void; + readonly target: (a: number) => void; + readonly call_backend: (a: number, b: number, c: number, d: number) => number; + readonly __wbindgen_export_0: (a: number) => number; + readonly __wbindgen_export_1: (a: number, b: number, c: number) => number; + readonly __wbindgen_export_2: WebAssembly.Table; + readonly __wbindgen_export_3: (a: number, b: number, c: number) => void; + readonly __wbindgen_add_to_stack_pointer: (a: number) => number; + readonly __wbindgen_export_4: (a: number, b: number) => void; + readonly __wbindgen_export_5: (a: number) => void; + readonly __wbindgen_export_6: (a: number, b: number, c: number, d: number) => void; +} + +/** +* Synchronously compiles the given `bytes` and instantiates the WebAssembly module. +* +* @param {BufferSource} bytes +* +* @returns {InitOutput} +*/ +export function initSync(bytes: BufferSource): InitOutput; + +/** +* If `module_or_path` is {RequestInfo} or {URL}, makes a request and +* for everything else, calls `WebAssembly.instantiate` directly. +* +* @param {InitInput | Promise} module_or_path +* +* @returns {Promise} +*/ +export default function init (module_or_path?: InitInput | Promise): Promise; + + +// USDPL customization +export function init_embedded(); diff --git a/templates/decky/src/usdpl-front/usdpl_front.js b/templates/decky/src/usdpl-front/usdpl_front.js new file mode 100644 index 0000000..eac3d62 --- /dev/null +++ b/templates/decky/src/usdpl-front/usdpl_front.js @@ -0,0 +1,499 @@ + +let wasm; + +const heap = new Array(32).fill(undefined); + +heap.push(undefined, null, true, false); + +function getObject(idx) { return heap[idx]; } + +let heap_next = heap.length; + +function dropObject(idx) { + if (idx < 36) return; + heap[idx] = heap_next; + heap_next = idx; +} + +function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; +} + +const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +let cachedUint8Memory0; +function getUint8Memory0() { + if (cachedUint8Memory0.byteLength === 0) { + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8Memory0; +} + +function getStringFromWasm0(ptr, len) { + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} + +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + +let WASM_VECTOR_LEN = 0; + +const cachedTextEncoder = new TextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length); + getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len); + + const mem = getUint8Memory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3); + const view = getUint8Memory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +let cachedInt32Memory0; +function getInt32Memory0() { + if (cachedInt32Memory0.byteLength === 0) { + cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); + } + return cachedInt32Memory0; +} + +let cachedFloat64Memory0; +function getFloat64Memory0() { + if (cachedFloat64Memory0.byteLength === 0) { + cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer); + } + return cachedFloat64Memory0; +} + +function makeMutClosure(arg0, arg1, dtor, f) { + const state = { a: arg0, b: arg1, cnt: 1, dtor }; + const real = (...args) => { + // First up with a closure we increment the internal reference + // count. This ensures that the Rust closure environment won't + // be deallocated while we're invoking it. + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + if (--state.cnt === 0) { + wasm.__wbindgen_export_2.get(state.dtor)(a, state.b); + + } else { + state.a = a; + } + } + }; + real.original = state; + + return real; +} +function __wbg_adapter_26(arg0, arg1, arg2) { + wasm.__wbindgen_export_3(arg0, arg1, addHeapObject(arg2)); +} + +/** +* Initialize the front-end library +* @param {number} port +*/ +export function init_usdpl(port) { + wasm.init_usdpl(port); +} + +/** +* Get the targeted plugin framework, or "any" if unknown +* @returns {string} +*/ +export function target() { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.target(retptr); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + return getStringFromWasm0(r0, r1); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + wasm.__wbindgen_export_4(r0, r1); + } +} + +let cachedUint32Memory0; +function getUint32Memory0() { + if (cachedUint32Memory0.byteLength === 0) { + cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer); + } + return cachedUint32Memory0; +} + +function passArrayJsValueToWasm0(array, malloc) { + const ptr = malloc(array.length * 4); + const mem = getUint32Memory0(); + for (let i = 0; i < array.length; i++) { + mem[ptr / 4 + i] = addHeapObject(array[i]); + } + WASM_VECTOR_LEN = array.length; + return ptr; +} +/** +* Call a function on the back-end. +* Returns null (None) if this fails for any reason. +* @param {string} name +* @param {any[]} parameters +* @returns {Promise} +*/ +export function call_backend(name, parameters) { + const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passArrayJsValueToWasm0(parameters, wasm.__wbindgen_export_0); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.call_backend(ptr0, len0, ptr1, len1); + return takeObject(ret); +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + wasm.__wbindgen_export_5(addHeapObject(e)); + } +} +function __wbg_adapter_54(arg0, arg1, arg2, arg3) { + wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); +} + +async function load(module, imports) { + if (typeof Response === 'function' && module instanceof Response) { + if (typeof WebAssembly.instantiateStreaming === 'function') { + try { + return await WebAssembly.instantiateStreaming(module, imports); + + } catch (e) { + if (module.headers.get('Content-Type') != 'application/wasm') { + console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); + + } else { + throw e; + } + } + } + + const bytes = await module.arrayBuffer(); + return await WebAssembly.instantiate(bytes, imports); + + } else { + const instance = await WebAssembly.instantiate(module, imports); + + if (instance instanceof WebAssembly.Instance) { + return { instance, module }; + + } else { + return instance; + } + } +} + +function getImports() { + const imports = {}; + imports.wbg = {}; + imports.wbg.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); + }; + imports.wbg.__wbindgen_string_new = function(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_string_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + var len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbindgen_number_new = function(arg0) { + const ret = arg0; + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_boolean_get = function(arg0) { + const v = getObject(arg0); + const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2; + return ret; + }; + imports.wbg.__wbindgen_number_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'number' ? obj : undefined; + getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret; + getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret); + }; + imports.wbg.__wbindgen_is_null = function(arg0) { + const ret = getObject(arg0) === null; + return ret; + }; + imports.wbg.__wbindgen_is_undefined = function(arg0) { + const ret = getObject(arg0) === undefined; + return ret; + }; + imports.wbg.__wbg_instanceof_Window_a2a08d3918d7d4d0 = function(arg0) { + const ret = getObject(arg0) instanceof Window; + return ret; + }; + imports.wbg.__wbg_fetch_23507368eed8d838 = function(arg0, arg1) { + const ret = getObject(arg0).fetch(getObject(arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_instanceof_Response_e928c54c1025470c = function(arg0) { + const ret = getObject(arg0) instanceof Response; + return ret; + }; + imports.wbg.__wbg_url_0f82030e7245954c = function(arg0, arg1) { + const ret = getObject(arg1).url; + const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + getInt32Memory0()[arg0 / 4 + 1] = len0; + getInt32Memory0()[arg0 / 4 + 0] = ptr0; + }; + imports.wbg.__wbg_text_5cb78830c1a11c5b = function() { return handleError(function (arg0) { + const ret = getObject(arg0).text(); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_newwithstrandinit_41c86e821f771b24 = function() { return handleError(function (arg0, arg1, arg2) { + const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_cb_drop = function(arg0) { + const obj = takeObject(arg0).original; + if (obj.cnt-- == 1) { + obj.a = 0; + return true; + } + const ret = false; + return ret; + }; + imports.wbg.__wbg_newnoargs_fc5356289219b93b = function(arg0, arg1) { + const ret = new Function(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_call_4573f605ca4b5f10 = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).call(getObject(arg1)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_new_306ce8d57919e6ae = function() { + const ret = new Object(); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_is_string = function(arg0) { + const ret = typeof(getObject(arg0)) === 'string'; + return ret; + }; + imports.wbg.__wbg_self_ba1ddafe9ea7a3a2 = function() { return handleError(function () { + const ret = self.self; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_window_be3cc430364fd32c = function() { return handleError(function () { + const ret = window.window; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_globalThis_56d9c9f814daeeee = function() { return handleError(function () { + const ret = globalThis.globalThis; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_global_8c35aeee4ac77f2b = function() { return handleError(function () { + const ret = global.global; + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_newwithlength_51bd08aed34ec6a3 = function(arg0) { + const ret = new Array(arg0 >>> 0); + return addHeapObject(ret); + }; + imports.wbg.__wbg_set_c1d04f8b45a036e7 = function(arg0, arg1, arg2) { + getObject(arg0)[arg1 >>> 0] = takeObject(arg2); + }; + imports.wbg.__wbg_call_9855a4612eb496cb = function() { return handleError(function (arg0, arg1, arg2) { + const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_new_78403b138428b684 = function(arg0, arg1) { + try { + var state0 = {a: arg0, b: arg1}; + var cb0 = (arg0, arg1) => { + const a = state0.a; + state0.a = 0; + try { + return __wbg_adapter_54(a, state0.b, arg0, arg1); + } finally { + state0.a = a; + } + }; + const ret = new Promise(cb0); + return addHeapObject(ret); + } finally { + state0.a = state0.b = 0; + } + }; + imports.wbg.__wbg_resolve_f269ce174f88b294 = function(arg0) { + const ret = Promise.resolve(getObject(arg0)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_then_1c698eedca15eed6 = function(arg0, arg1) { + const ret = getObject(arg0).then(getObject(arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_then_4debc41d4fc92ce5 = function(arg0, arg1, arg2) { + const ret = getObject(arg0).then(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); + }; + imports.wbg.__wbg_parse_5b823b8686817eb8 = function() { return handleError(function (arg0, arg1) { + const ret = JSON.parse(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_stringify_cf20dc96bee34a66 = function() { return handleError(function (arg0) { + const ret = JSON.stringify(getObject(arg0)); + return addHeapObject(ret); + }, arguments) }; + imports.wbg.__wbg_set_b12cd0ab82903c2f = function() { return handleError(function (arg0, arg1, arg2) { + const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2)); + return ret; + }, arguments) }; + imports.wbg.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); + }; + imports.wbg.__wbindgen_closure_wrapper575 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 47, __wbg_adapter_26); + return addHeapObject(ret); + }; + + return imports; +} + +function initMemory(imports, maybe_memory) { + +} + +function finalizeInit(instance, module) { + wasm = instance.exports; + init.__wbindgen_wasm_module = module; + cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer); + cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); + cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer); + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + + + return wasm; +} + +function initSync(bytes) { + const imports = getImports(); + + initMemory(imports); + + const module = new WebAssembly.Module(bytes); + const instance = new WebAssembly.Instance(module, imports); + + return finalizeInit(instance, module); +} + +async function init(input) { + if (typeof input === 'undefined') { + input = new URL('usdpl_front_bg.wasm', import.meta.url); + } + const imports = getImports(); + + if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) { + input = fetch(input); + } + + initMemory(imports); + + const { instance, module } = await load(await input, imports); + + return finalizeInit(instance, module); +} + +export { initSync } +export default init; + + +// USDPL customization +const encoded = "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"; + +function asciiToBinary(str) { + if (typeof atob === 'function') { + return atob(str) + } else { + return new Buffer(str, 'base64').toString('binary'); + } +} + +function decode() { + var binaryString = asciiToBinary(encoded); + var bytes = new Uint8Array(binaryString.length); + for (var i = 0; i < binaryString.length; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return (async function() {return new Response(bytes.buffer);})(); +} + +export function init_embedded() { + return init(decode()) +} diff --git a/templates/decky/src/usdpl-front/usdpl_front_bg.wasm b/templates/decky/src/usdpl-front/usdpl_front_bg.wasm new file mode 100644 index 0000000..e6fc953 Binary files /dev/null and b/templates/decky/src/usdpl-front/usdpl_front_bg.wasm differ diff --git a/templates/decky/src/usdpl-front/usdpl_front_bg.wasm.d.ts b/templates/decky/src/usdpl-front/usdpl_front_bg.wasm.d.ts new file mode 100644 index 0000000..357dc02 --- /dev/null +++ b/templates/decky/src/usdpl-front/usdpl_front_bg.wasm.d.ts @@ -0,0 +1,14 @@ +/* tslint:disable */ +/* eslint-disable */ +export const memory: WebAssembly.Memory; +export function init_usdpl(a: number): void; +export function target(a: number): void; +export function call_backend(a: number, b: number, c: number, d: number): number; +export function __wbindgen_export_0(a: number): number; +export function __wbindgen_export_1(a: number, b: number, c: number): number; +export const __wbindgen_export_2: WebAssembly.Table; +export function __wbindgen_export_3(a: number, b: number, c: number): void; +export function __wbindgen_add_to_stack_pointer(a: number): number; +export function __wbindgen_export_4(a: number, b: number): void; +export function __wbindgen_export_5(a: number): void; +export function __wbindgen_export_6(a: number, b: number, c: number, d: number): void; diff --git a/templates/decky/tsconfig.json b/templates/decky/tsconfig.json new file mode 100644 index 0000000..13b0c35 --- /dev/null +++ b/templates/decky/tsconfig.json @@ -0,0 +1,23 @@ +{ + "compilerOptions": { + "outDir": "dist", + "module": "ESNext", + "target": "ES2020", + "jsx": "react", + "jsxFactory": "window.SP_REACT.createElement", + "declaration": false, + "moduleResolution": "node", + "noUnusedLocals": true, + "noUnusedParameters": true, + "esModuleInterop": true, + "noImplicitReturns": true, + "noImplicitThis": true, + "noImplicitAny": true, + "strict": true, + "suppressImplicitAnyIndexErrors": true, + "allowSyntheticDefaultImports": true, + "skipLibCheck": true + }, + "include": ["src"], + "exclude": ["node_modules"] +} diff --git a/usdpl-front/Cargo.toml b/usdpl-front/Cargo.toml index 23a2542..9a8598f 100644 --- a/usdpl-front/Cargo.toml +++ b/usdpl-front/Cargo.toml @@ -12,7 +12,7 @@ description = "Universal Steam Deck Plugin Library front-end designed for WASM" crate-type = ["cdylib", "rlib"] [features] -default = ["encrypt"] +default = [] decky = ["usdpl-core/decky"] crankshaft = ["usdpl-core/crankshaft"] debug = ["console_error_panic_hook"] diff --git a/usdpl-front/src/connection.rs b/usdpl-front/src/connection.rs index 177b2be..fa9051d 100644 --- a/usdpl-front/src/connection.rs +++ b/usdpl-front/src/connection.rs @@ -13,6 +13,7 @@ use web_sys::{Request, RequestInit, RequestMode, Response}; use usdpl_core::serdes::{Dumpable, Loadable, Primitive}; use usdpl_core::socket; +#[cfg(feature = "encrypt")] const NONCE: [u8; socket::NONCE_SIZE]= [0u8; socket::NONCE_SIZE]; pub async fn send_js( diff --git a/usdpl-front/src/lib.rs b/usdpl-front/src/lib.rs index 2b79b7e..053dea8 100644 --- a/usdpl-front/src/lib.rs +++ b/usdpl-front/src/lib.rs @@ -16,7 +16,8 @@ use usdpl_core::{socket::Packet, RemoteCall}; //const REMOTE_CALL_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); //const REMOTE_PORT: std::sync::atomic::AtomicU16 = std::sync::atomic::AtomicU16::new(31337); -static mut CTX: UsdplContext = UsdplContext { port: 31337, id: 1, key: Vec::new() }; +static mut CTX: UsdplContext = UsdplContext { port: 31337, id: 1, +#[cfg(feature = "encrypt")] key: Vec::new() }; #[cfg(feature = "encrypt")] fn encryption_key() -> Vec { @@ -36,6 +37,7 @@ fn get_port() -> u16 { unsafe { CTX.port } } +#[cfg(feature = "encrypt")] fn get_key() -> Vec { unsafe { CTX.key.clone() } }