diff --git a/v2/internal/frontend/assetserver/assetserver.go b/v2/internal/frontend/assetserver/assetserver.go deleted file mode 100644 index f191fb06d..000000000 --- a/v2/internal/frontend/assetserver/assetserver.go +++ /dev/null @@ -1,78 +0,0 @@ -package assetserver - -import ( - "bytes" - "embed" - "fmt" - "github.com/leaanthony/debme" - "github.com/leaanthony/slicer" - "github.com/wailsapp/wails/v2/internal/frontend/runtime" - "io/fs" - "path/filepath" - "strings" -) - -type AssetServer struct { - assets debme.Debme - indexFile []byte - runtimeJS string -} - -func NewAssetServer(assets embed.FS, bindingsJSON string) (*AssetServer, error) { - result := &AssetServer{ - runtimeJS: `window.wailsbindings='` + bindingsJSON + `';` + runtime.RuntimeJS, - } - err := result.init(assets) - return result, err -} - -func (a *AssetServer) IndexHTML() string { - return string(a.indexFile) -} - -func injectScript(input string, script string) ([]byte, error) { - splits := strings.Split(input, "") - if len(splits) != 2 { - return nil, fmt.Errorf("unable to locate a tag in your html") - } - - var result bytes.Buffer - result.WriteString(splits[0]) - result.WriteString("") - result.WriteString(script) - result.WriteString(splits[1]) - return result.Bytes(), nil -} - -func processAssets(assets embed.FS) (debme.Debme, error) { - - result, err := debme.FS(assets, ".") - if err != nil { - return result, err - } - // Find index.html - stat, err := fs.Stat(assets, "index.html") - if stat != nil { - return debme.FS(assets, ".") - } - var indexFiles slicer.StringSlicer - err = fs.WalkDir(result, ".", func(path string, d fs.DirEntry, err error) error { - if err != nil { - return err - } - if strings.HasSuffix(path, "index.html") { - indexFiles.Add(path) - } - return nil - }) - if err != nil { - return debme.Debme{}, err - } - - if indexFiles.Length() > 1 { - return debme.Debme{}, fmt.Errorf("multiple 'index.html' files found in assets") - } - - path, _ := filepath.Split(indexFiles.AsSlice()[0]) - return debme.FS(assets, path) -} diff --git a/v2/internal/frontend/assetserver/assetserver_desktop.go b/v2/internal/frontend/assetserver/assetserver_desktop.go index 27431efe2..59af215a2 100644 --- a/v2/internal/frontend/assetserver/assetserver_desktop.go +++ b/v2/internal/frontend/assetserver/assetserver_desktop.go @@ -1,12 +1,89 @@ +//go:build desktop // +build desktop package assetserver import ( + "bytes" "embed" + "fmt" + "github.com/leaanthony/debme" + "github.com/leaanthony/slicer" + "github.com/wailsapp/wails/v2/internal/frontend/runtime" + "io/fs" "net/http" + "path/filepath" + "strings" ) +type AssetServer struct { + assets debme.Debme + indexFile []byte + runtimeJS []byte +} + +func NewAssetServer(assets embed.FS, bindingsJSON string) (*AssetServer, error) { + result := &AssetServer{} + var buffer bytes.Buffer + buffer.Write(runtime.IPCJS) + buffer.WriteString(`window.wailsbindings='` + bindingsJSON + `';` + "\n") + buffer.Write(runtime.RuntimeJS) + result.runtimeJS = buffer.Bytes() + err := result.init(assets) + return result, err +} + +func (a *AssetServer) IndexHTML() string { + return string(a.indexFile) +} + +func injectScript(input string, script string) ([]byte, error) { + splits := strings.Split(input, "") + if len(splits) != 2 { + return nil, fmt.Errorf("unable to locate a tag in your html") + } + + var result bytes.Buffer + result.WriteString(splits[0]) + result.WriteString("") + result.WriteString(script) + result.WriteString(splits[1]) + return result.Bytes(), nil +} + +func processAssets(assets embed.FS) (debme.Debme, error) { + + result, err := debme.FS(assets, ".") + if err != nil { + return result, err + } + // Find index.html + stat, err := fs.Stat(assets, "index.html") + if stat != nil { + return debme.FS(assets, ".") + } + var indexFiles slicer.StringSlicer + err = fs.WalkDir(result, ".", func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if strings.HasSuffix(path, "index.html") { + indexFiles.Add(path) + } + return nil + }) + if err != nil { + return debme.Debme{}, err + } + + if indexFiles.Length() > 1 { + return debme.Debme{}, fmt.Errorf("multiple 'index.html' files found in assets") + } + + path, _ := filepath.Split(indexFiles.AsSlice()[0]) + return debme.FS(assets, path) +} + func (a *AssetServer) init(assets embed.FS) error { var err error @@ -18,7 +95,7 @@ func (a *AssetServer) init(assets embed.FS) error { if err != nil { return err } - a.indexFile, err = injectScript(string(indexHTML), "") + a.indexFile, err = injectScript(string(indexHTML), ``) if err != nil { return err } @@ -31,6 +108,10 @@ func (a *AssetServer) Load(filename string) ([]byte, string, error) { switch filename { case "/": content = a.indexFile + case "/wails/runtime.js": + content = a.runtimeJS + case "/wails/ipc.js": + content = runtime.IPCJS default: content, err = a.assets.ReadFile(filename) } diff --git a/v2/internal/frontend/assetserver/assetserver_desktop_test.go b/v2/internal/frontend/assetserver/assetserver_desktop_test.go deleted file mode 100644 index 461396785..000000000 --- a/v2/internal/frontend/assetserver/assetserver_desktop_test.go +++ /dev/null @@ -1,48 +0,0 @@ -// +build desktop - -package assetserver - -import ( - "embed" - "github.com/matryer/is" - "github.com/wailsapp/wails/v2/internal/frontend/assetserver/testdata" - "strconv" - "testing" -) - -var runtimeInjection = `` -var expected = `` + runtimeInjection + `` - -//go:embed testdata/subdir -var subdir embed.FS - -//go:embed testdata -var multiple embed.FS - -func TestAssetServer_Init(t *testing.T) { - - is2 := is.New(t) - - tests := []struct { - assets embed.FS - want string - wantErr bool - }{ - {testdata.TopLevelFS, expected, false}, - {subdir, expected, false}, - {multiple, expected, true}, - } - - for idx, tt := range tests { - t.Run(strconv.Itoa(idx), func(t *testing.T) { - server, err := NewAssetServer(tt.assets) - if tt.wantErr { - is2.True(err != nil) - } else { - is2.NoErr(err) - is2.Equal(string(server.indexFile), tt.want) - } - }) - } - -} diff --git a/v2/internal/frontend/devserver/runtime_debug_windows.js b/v2/internal/frontend/devserver/runtime_debug_windows.js new file mode 100644 index 000000000..0f231bde0 --- /dev/null +++ b/v2/internal/frontend/devserver/runtime_debug_windows.js @@ -0,0 +1,304 @@ +(() => { + var __defProp = Object.defineProperty; + var __markAsModule = (target) => __defProp(target, "__esModule", {value: true}); + var __export = (target, all) => { + __markAsModule(target); + for (var name in all) + __defProp(target, name, {get: all[name], enumerable: true}); + }; + + // desktop/log.js + var log_exports = {}; + __export(log_exports, { + LogDebug: () => LogDebug, + LogError: () => LogError, + LogFatal: () => LogFatal, + LogInfo: () => LogInfo, + LogLevel: () => LogLevel, + LogPrint: () => LogPrint, + LogTrace: () => LogTrace, + LogWarning: () => LogWarning, + SetLogLevel: () => SetLogLevel + }); + + // desktop/ipc.js + var listeners = []; + + function SendMessage(message) { + if (true) { + window.chrome.webview.postMessage(message); + } else if (false) { + window.blah(); + } else { + console.error("Unsupported Platform"); + } + if (listeners.length > 0) { + for (let i = 0; i < listeners.length; i++) { + listeners[i](message); + } + } + } + + // desktop/log.js + function sendLogMessage(level, message) { + SendMessage("L" + level + message); + } + + function LogTrace(message) { + sendLogMessage("T", message); + } + + function LogPrint(message) { + sendLogMessage("P", message); + } + + function LogDebug(message) { + sendLogMessage("D", message); + } + + function LogInfo(message) { + sendLogMessage("I", message); + } + + function LogWarning(message) { + sendLogMessage("W", message); + } + + function LogError(message) { + sendLogMessage("E", message); + } + + function LogFatal(message) { + sendLogMessage("F", message); + } + + function SetLogLevel(loglevel) { + sendLogMessage("S", loglevel); + } + + var LogLevel = { + TRACE: 1, + DEBUG: 2, + INFO: 3, + WARNING: 4, + ERROR: 5 + }; + + // desktop/events.js + var Listener = class { + constructor(callback, maxCallbacks) { + maxCallbacks = maxCallbacks || -1; + this.Callback = (data) => { + callback.apply(null, data); + if (maxCallbacks === -1) { + return false; + } + maxCallbacks -= 1; + return maxCallbacks === 0; + }; + } + }; + var eventListeners = {}; + + function EventsOnMultiple(eventName, callback, maxCallbacks) { + eventListeners[eventName] = eventListeners[eventName] || []; + const thisListener = new Listener(callback, maxCallbacks); + eventListeners[eventName].push(thisListener); + } + + function EventsOn(eventName, callback) { + EventsOnMultiple(eventName, callback, -1); + } + + function EventsOnce(eventName, callback) { + EventsOnMultiple(eventName, callback, 1); + } + + function notifyListeners(eventData) { + let eventName = eventData.name; + if (eventListeners[eventName]) { + const newEventListenerList = eventListeners[eventName].slice(); + for (let count = 0; count < eventListeners[eventName].length; count += 1) { + const listener = eventListeners[eventName][count]; + let data = eventData.data; + const destroy = listener.Callback(data); + if (destroy) { + newEventListenerList.splice(count, 1); + } + } + eventListeners[eventName] = newEventListenerList; + } + } + + function EventsNotify(notifyMessage) { + console.log("EventsNotify"); + let message; + try { + message = JSON.parse(notifyMessage); + } catch (e) { + const error = "Invalid JSON passed to Notify: " + notifyMessage; + throw new Error(error); + } + console.log({message}); + notifyListeners(message); + } + + function EventsEmit(eventName) { + const payload = { + name: eventName, + data: [].slice.apply(arguments).slice(1) + }; + notifyListeners(payload); + SendMessage("EE" + JSON.stringify(payload)); + } + + function EventsOff(eventName) { + eventListeners.delete(eventName); + SendMessage("EX" + eventName); + } + + // desktop/calls.js + var callbacks = {}; + + function cryptoRandom() { + var array = new Uint32Array(1); + return window.crypto.getRandomValues(array)[0]; + } + + function basicRandom() { + return Math.random() * 9007199254740991; + } + + var randomFunc; + if (window.crypto) { + randomFunc = cryptoRandom; + } else { + randomFunc = basicRandom; + } + + function Call(name, args, timeout) { + if (timeout == null) { + timeout = 0; + } + return new Promise(function (resolve, reject) { + var callbackID; + do { + callbackID = name + "-" + randomFunc(); + } while (callbacks[callbackID]); + var timeoutHandle; + if (timeout > 0) { + timeoutHandle = setTimeout(function () { + reject(Error("Call to " + name + " timed out. Request ID: " + callbackID)); + }, timeout); + } + callbacks[callbackID] = { + timeoutHandle, + reject, + resolve + }; + try { + const payload = { + name, + args, + callbackID + }; + SendMessage("C" + JSON.stringify(payload)); + } catch (e) { + console.error(e); + } + }); + } + + function Callback(incomingMessage) { + var message; + try { + message = JSON.parse(incomingMessage); + } catch (e) { + const error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`; + wails.LogDebug(error); + throw new Error(error); + } + var callbackID = message.callbackid; + var callbackData = callbacks[callbackID]; + if (!callbackData) { + const error = `Callback '${callbackID}' not registered!!!`; + console.error(error); + throw new Error(error); + } + clearTimeout(callbackData.timeoutHandle); + delete callbacks[callbackID]; + if (message.error) { + callbackData.reject(message.error); + } else { + callbackData.resolve(message.result); + } + } + + // desktop/bindings.js + window.backend = {}; + + function SetBindings(bindingsMap) { + try { + bindingsMap = JSON.parse(bindingsMap); + } catch (e) { + console.error(e); + } + window.backend = window.backend || {}; + Object.keys(bindingsMap).forEach((packageName) => { + window.backend[packageName] = window.backend[packageName] || {}; + Object.keys(bindingsMap[packageName]).forEach((structName) => { + window.backend[packageName][structName] = window.backend[packageName][structName] || {}; + Object.keys(bindingsMap[packageName][structName]).forEach((methodName) => { + window.backend[packageName][structName][methodName] = function () { + let timeout = 0; + + function dynamic() { + const args = [].slice.call(arguments); + return Call([packageName, structName, methodName].join("."), args, timeout); + } + + dynamic.setTimeout = function (newTimeout) { + timeout = newTimeout; + }; + dynamic.getTimeout = function () { + return timeout; + }; + return dynamic; + }(); + }); + }); + }); + } + + // desktop/main.js + window.backend = {}; + window.runtime = { + ...log_exports, + EventsOn, + EventsOnce, + EventsOnMultiple, + EventsEmit, + EventsOff + }; + window.wails = { + Callback, + EventsNotify, + SetBindings + }; + window.wails.SetBindings(window.wailsbindings); + delete window.wails.SetBindings; + delete window.wailsbindings; + window.addEventListener("mousedown", (e) => { + let currentElement = e.target; + while (currentElement != null) { + if (currentElement.hasAttribute("data-wails-no-drag")) { + break; + } else if (currentElement.hasAttribute("data-wails-drag")) { + SendMessage("drag"); + break; + } + currentElement = currentElement.parentElement; + } + }); +})(); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["desktop/log.js", "desktop/ipc.js", "desktop/events.js", "desktop/calls.js", "desktop/bindings.js", "desktop/main.js"],
  "sourcesContent": ["/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe lightweight framework for web-like apps\r\n(c) Lea Anthony 2019-present\r\n*/\r\n\r\n/* jshint esversion: 6 */\r\n\r\nimport {SendMessage} from './ipc';\r\n\r\n/**\r\n * Sends a log message to the backend with the given level + message\r\n *\r\n * @param {string} level\r\n * @param {string} message\r\n */\r\nfunction sendLogMessage(level, message) {\r\n\r\n\t// Log Message format:\r\n\t// l[type][message]\r\n\tSendMessage('L' + level + message);\r\n}\r\n\r\n/**\r\n * Log the given trace message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogTrace(message) {\r\n\tsendLogMessage('T', message);\r\n}\r\n\r\n/**\r\n * Log the given message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogPrint(message) {\r\n\tsendLogMessage('P', message);\r\n}\r\n\r\n/**\r\n * Log the given debug message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogDebug(message) {\r\n\tsendLogMessage('D', message);\r\n}\r\n\r\n/**\r\n * Log the given info message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogInfo(message) {\r\n\tsendLogMessage('I', message);\r\n}\r\n\r\n/**\r\n * Log the given warning message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogWarning(message) {\r\n\tsendLogMessage('W', message);\r\n}\r\n\r\n/**\r\n * Log the given error message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogError(message) {\r\n\tsendLogMessage('E', message);\r\n}\r\n\r\n/**\r\n * Log the given fatal message with the backend\r\n *\r\n * @export\r\n * @param {string} message\r\n */\r\nexport function LogFatal(message) {\r\n\tsendLogMessage('F', message);\r\n}\r\n\r\n/**\r\n * Sets the Log level to the given log level\r\n *\r\n * @export\r\n * @param {number} loglevel\r\n */\r\nexport function SetLogLevel(loglevel) {\r\n\tsendLogMessage('S', loglevel);\r\n}\r\n\r\n// Log levels\r\nexport const LogLevel = {\r\n\tTRACE: 1,\r\n\tDEBUG: 2,\r\n\tINFO: 3,\r\n\tWARNING: 4,\r\n\tERROR: 5,\r\n};\r\n", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe lightweight framework for web-like apps\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\n// IPC Listeners\r\nconst listeners = [];\r\n\r\n/**\r\n * Adds a listener to IPC messages\r\n * @param {function} callback\r\n */\r\nexport function AddIPCListener(callback) {\r\n\tlisteners.push(callback);\r\n}\r\n\r\n/**\r\n * SendMessage sends the given message to the backend\r\n *\r\n * @param {string} message\r\n */\r\nexport function SendMessage(message) {\r\n\r\n\t// Call Platform specific invoke method\r\n\tif (PLATFORM === \"windows\") {\r\n\t\twindow.chrome.webview.postMessage(message);\r\n\t} else if (PLATFORM === \"darwin\") {\r\n\t\twindow.blah();\r\n\t} else {\r\n\t\tconsole.error(\"Unsupported Platform\");\r\n\t}\r\n\r\n\t// Also send to listeners\r\n\tif (listeners.length > 0) {\r\n\t\tfor (let i = 0; i < listeners.length; i++) {\r\n\t\t\tlisteners[i](message);\r\n\t\t}\r\n\t}\r\n}\r\n", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe lightweight framework for web-like apps\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nimport {SendMessage} from './ipc';\r\n\r\n// Defines a single listener with a maximum number of times to callback\r\n\r\n/**\r\n * The Listener class defines a listener! :-)\r\n *\r\n * @class Listener\r\n */\r\nclass Listener {\r\n    /**\r\n     * Creates an instance of Listener.\r\n     * @param {function} callback\r\n     * @param {number} maxCallbacks\r\n     * @memberof Listener\r\n     */\r\n    constructor(callback, maxCallbacks) {\r\n        // Default of -1 means infinite\r\n        maxCallbacks = maxCallbacks || -1;\r\n        // Callback invokes the callback with the given data\r\n        // Returns true if this listener should be destroyed\r\n        this.Callback = (data) => {\r\n            callback.apply(null, data);\r\n            // If maxCallbacks is infinite, return false (do not destroy)\r\n            if (maxCallbacks === -1) {\r\n                return false;\r\n            }\r\n            // Decrement maxCallbacks. Return true if now 0, otherwise false\r\n            maxCallbacks -= 1;\r\n            return maxCallbacks === 0;\r\n        };\r\n    }\r\n}\r\n\r\nlet eventListeners = {};\r\n\r\n/**\r\n * Registers an event listener that will be invoked `maxCallbacks` times before being destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n * @param {number} maxCallbacks\r\n */\r\nexport function EventsOnMultiple(eventName, callback, maxCallbacks) {\r\n    eventListeners[eventName] = eventListeners[eventName] || [];\r\n    const thisListener = new Listener(callback, maxCallbacks);\r\n    eventListeners[eventName].push(thisListener);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked every time the event is emitted\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n */\r\nexport function EventsOn(eventName, callback) {\r\n    EventsOnMultiple(eventName, callback, -1);\r\n}\r\n\r\n/**\r\n * Registers an event listener that will be invoked once then destroyed\r\n *\r\n * @export\r\n * @param {string} eventName\r\n * @param {function} callback\r\n */\r\nexport function EventsOnce(eventName, callback) {\r\n    EventsOnMultiple(eventName, callback, 1);\r\n}\r\n\r\nfunction notifyListeners(eventData) {\r\n\r\n    // Get the event name\r\n    let eventName = eventData.name;\r\n\r\n    // Check if we have any listeners for this event\r\n    if (eventListeners[eventName]) {\r\n\r\n        // Keep a list of listener indexes to destroy\r\n        const newEventListenerList = eventListeners[eventName].slice();\r\n\r\n        // Iterate listeners\r\n        for (let count = 0; count < eventListeners[eventName].length; count += 1) {\r\n\r\n            // Get next listener\r\n            const listener = eventListeners[eventName][count];\r\n\r\n            let data = eventData.data;\r\n\r\n            // Do the callback\r\n            const destroy = listener.Callback(data);\r\n            if (destroy) {\r\n                // if the listener indicated to destroy itself, add it to the destroy list\r\n                newEventListenerList.splice(count, 1);\r\n            }\r\n        }\r\n\r\n        // Update callbacks with new list of listeners\r\n        eventListeners[eventName] = newEventListenerList;\r\n    }\r\n}\r\n\r\n/**\r\n * Notify informs frontend listeners that an event was emitted with the given data\r\n *\r\n * @export\r\n * @param {string} notifyMessage - encoded notification message\r\n\r\n */\r\nexport function EventsNotify(notifyMessage) {\r\n    console.log(\"EventsNotify\");\r\n\r\n    // Parse the message\r\n    let message;\r\n    try {\r\n        message = JSON.parse(notifyMessage);\r\n    } catch (e) {\r\n        const error = 'Invalid JSON passed to Notify: ' + notifyMessage;\r\n        throw new Error(error);\r\n    }\r\n    console.log({message});\r\n    notifyListeners(message);\r\n}\r\n\r\n/**\r\n * Emit an event with the given name and data\r\n *\r\n * @export\r\n * @param {string} eventName\r\n */\r\nexport function EventsEmit(eventName) {\r\n\r\n    const payload = {\r\n        name: eventName,\r\n        data: [].slice.apply(arguments).slice(1),\r\n    };\r\n\r\n    // Notify JS listeners\r\n    notifyListeners(payload);\r\n\r\n    // Notify Go listeners\r\n    SendMessage('EE' + JSON.stringify(payload));\r\n}\r\n\r\nexport function EventsOff(eventName) {\r\n    // Remove local listeners\r\n    eventListeners.delete(eventName);\r\n\r\n    // Notify Go listeners\r\n    SendMessage('EX' + eventName);\r\n}", "/*\r\n _       __      _ __\r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe lightweight framework for web-like apps\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nimport { SendMessage } from './ipc';\r\n\r\nvar callbacks = {};\r\n\r\n/**\r\n * Returns a number from the native browser random function\r\n *\r\n * @returns number\r\n */\r\nfunction cryptoRandom() {\r\n\tvar array = new Uint32Array(1);\r\n\treturn window.crypto.getRandomValues(array)[0];\r\n}\r\n\r\n/**\r\n * Returns a number using da old-skool Math.Random\r\n * I likes to call it LOLRandom\r\n *\r\n * @returns number\r\n */\r\nfunction basicRandom() {\r\n\treturn Math.random() * 9007199254740991;\r\n}\r\n\r\n// Pick a random number function based on browser capability\r\nvar randomFunc;\r\nif (window.crypto) {\r\n\trandomFunc = cryptoRandom;\r\n} else {\r\n\trandomFunc = basicRandom;\r\n}\r\n\r\n\r\n/**\r\n * Call sends a message to the backend to call the binding with the\r\n * given data. A promise is returned and will be completed when the\r\n * backend responds. This will be resolved when the call was successful\r\n * or rejected if an error is passed back.\r\n * There is a timeout mechanism. If the call doesn't respond in the given\r\n * time (in milliseconds) then the promise is rejected.\r\n *\r\n * @export\r\n * @param {string} name\r\n * @param {string} args\r\n * @param {number=} timeout\r\n * @returns\r\n */\r\nexport function Call(name, args, timeout) {\r\n\r\n\t// Timeout infinite by default\r\n\tif (timeout == null) {\r\n\t\ttimeout = 0;\r\n\t}\r\n\r\n\t// Create a promise\r\n\treturn new Promise(function (resolve, reject) {\r\n\r\n\t\t// Create a unique callbackID\r\n\t\tvar callbackID;\r\n\t\tdo {\r\n\t\t\tcallbackID = name + '-' + randomFunc();\r\n\t\t} while (callbacks[callbackID]);\r\n\r\n\t\t// Set timeout\r\n\t\tif (timeout > 0) {\r\n\t\t\tvar timeoutHandle = setTimeout(function () {\r\n\t\t\t\treject(Error('Call to ' + name + ' timed out. Request ID: ' + callbackID));\r\n\t\t\t}, timeout);\r\n\t\t}\r\n\r\n\t\t// Store callback\r\n\t\tcallbacks[callbackID] = {\r\n\t\t\ttimeoutHandle: timeoutHandle,\r\n\t\t\treject: reject,\r\n\t\t\tresolve: resolve\r\n\t\t};\r\n\r\n\t\ttry {\r\n\t\t\tconst payload = {\r\n\t\t\t\tname,\r\n\t\t\t\targs,\r\n\t\t\t\tcallbackID,\r\n\t\t\t};\r\n\r\n\t\t\t// Make the call\r\n\t\t\tSendMessage('C' + JSON.stringify(payload));\r\n\t\t} catch (e) {\r\n\t\t\t// eslint-disable-next-line\r\n\t\t\tconsole.error(e);\r\n\t\t}\r\n\t});\r\n}\r\n\r\n\r\n\r\n/**\r\n * Called by the backend to return data to a previously called\r\n * binding invocation\r\n *\r\n * @export\r\n * @param {string} incomingMessage\r\n */\r\nexport function Callback(incomingMessage) {\r\n\t// Decode the message - Credit: https://stackoverflow.com/a/13865680\r\n\t//incomingMessage = decodeURIComponent(incomingMessage.replace(/\\s+/g, '').replace(/[0-9a-f]{2}/g, '%$&'));\r\n\r\n\t// Parse the message\r\n\tvar message;\r\n\ttry {\r\n\t\tmessage = JSON.parse(incomingMessage);\r\n\t} catch (e) {\r\n\t\tconst error = `Invalid JSON passed to callback: ${e.message}. Message: ${incomingMessage}`;\r\n\t\twails.LogDebug(error);\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tvar callbackID = message.callbackid;\r\n\tvar callbackData = callbacks[callbackID];\r\n\tif (!callbackData) {\r\n\t\tconst error = `Callback '${callbackID}' not registered!!!`;\r\n\t\tconsole.error(error); // eslint-disable-line\r\n\t\tthrow new Error(error);\r\n\t}\r\n\tclearTimeout(callbackData.timeoutHandle);\r\n\r\n\tdelete callbacks[callbackID];\r\n\r\n\tif (message.error) {\r\n\t\tcallbackData.reject(message.error);\r\n\t} else {\r\n\t\tcallbackData.resolve(message.result);\r\n\t}\r\n}\r\n", "/*\r\n _       __      _ __    \r\n| |     / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  ) \r\n|__/|__/\\__,_/_/_/____/  \r\nThe lightweight framework for web-like apps\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 6 */\r\n\r\nimport { Call } from './calls';\r\n\r\nwindow.backend = {};\r\n\r\nexport function SetBindings(bindingsMap) {\r\n\ttry {\r\n\t\tbindingsMap = JSON.parse(bindingsMap);\r\n\t} catch (e) {\r\n\t\tconsole.error(e);\r\n\t}\r\n\r\n\t// Initialise the backend map\r\n\twindow.backend = window.backend || {};\r\n\r\n\t// Iterate package names\r\n\tObject.keys(bindingsMap).forEach((packageName) => {\r\n\r\n\t\t// Create inner map if it doesn't exist\r\n\t\twindow.backend[packageName] = window.backend[packageName] || {};\r\n\r\n\t\t// Iterate struct names\r\n\t\tObject.keys(bindingsMap[packageName]).forEach((structName) => {\r\n\r\n\t\t\t// Create inner map if it doesn't exist\r\n\t\t\twindow.backend[packageName][structName] = window.backend[packageName][structName] || {};\r\n\r\n\t\t\tObject.keys(bindingsMap[packageName][structName]).forEach((methodName) => {\r\n\r\n\t\t\t\twindow.backend[packageName][structName][methodName] = function () {\r\n\r\n\t\t\t\t\t// No timeout by default\r\n\t\t\t\t\tlet timeout = 0;\r\n\r\n\t\t\t\t\t// Actual function\r\n\t\t\t\t\tfunction dynamic() {\r\n\t\t\t\t\t\tconst args = [].slice.call(arguments);\r\n\t\t\t\t\t\treturn Call([packageName, structName, methodName].join('.'), args, timeout);\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Allow setting timeout to function\r\n\t\t\t\t\tdynamic.setTimeout = function (newTimeout) {\r\n\t\t\t\t\t\ttimeout = newTimeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\t// Allow getting timeout to function\r\n\t\t\t\t\tdynamic.getTimeout = function () {\r\n\t\t\t\t\t\treturn timeout;\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\treturn dynamic;\r\n\t\t\t\t}();\r\n\t\t\t});\r\n\t\t});\r\n\t});\r\n}\r\n", "/*\r\n _\t   __\t  _ __\r\n| |\t / /___ _(_) /____\r\n| | /| / / __ `/ / / ___/\r\n| |/ |/ / /_/ / / (__  )\r\n|__/|__/\\__,_/_/_/____/\r\nThe lightweight framework for web-like apps\r\n(c) Lea Anthony 2019-present\r\n*/\r\n/* jshint esversion: 9 */\r\nimport * as Log from './log';\r\nimport {EventsEmit, EventsNotify, EventsOff, EventsOn, EventsOnce, EventsOnMultiple} from './events';\r\nimport {Callback} from './calls';\r\nimport {SetBindings} from \"./bindings\";\r\n// import {AddScript, DisableDefaultContextMenu, InjectCSS} from './utils';\r\nimport {SendMessage} from './ipc';\r\n\r\n// Backend is where the Go struct wrappers get bound to\r\nwindow.backend = {};\r\n\r\nwindow.runtime = {\r\n    ...Log,\r\n    EventsOn,\r\n    EventsOnce,\r\n    EventsOnMultiple,\r\n    EventsEmit,\r\n    EventsOff,\r\n};\r\n\r\n// Initialise global if not already\r\nwindow.wails = {\r\n    Callback,\r\n    EventsNotify,\r\n    SetBindings,\r\n};\r\n\r\nwindow.wails.SetBindings(window.wailsbindings);\r\ndelete window.wails['SetBindings'];\r\ndelete window['wailsbindings'];\r\n\r\n// Setup drag handler\r\n// Based on code from: https://github.com/patr0nus/DeskGap\r\nwindow.addEventListener('mousedown', (e) => {\r\n    let currentElement = e.target;\r\n    while (currentElement != null) {\r\n        if (currentElement.hasAttribute('data-wails-no-drag')) {\r\n            break;\r\n        } else if (currentElement.hasAttribute('data-wails-drag')) {\r\n            SendMessage(\"drag\");\r\n            break;\r\n        }\r\n        currentElement = currentElement.parentElement;\r\n    }\r\n});\r\n"],
  "mappings": "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",
  "names": []
}
 diff --git a/v2/internal/frontend/runtime/desktop/calls.js b/v2/internal/frontend/runtime/desktop/calls.js index 68e5ed129..0b8e809e6 100644 --- a/v2/internal/frontend/runtime/desktop/calls.js +++ b/v2/internal/frontend/runtime/desktop/calls.js @@ -9,8 +9,6 @@ The lightweight framework for web-like apps */ /* jshint esversion: 6 */ -import {SendMessage} from './ipc'; - var callbacks = {}; /** @@ -95,7 +93,7 @@ export function Call(name, args, timeout) { }; // Make the call - SendMessage('C' + JSON.stringify(payload)); + window.WailsInvoke('C' + JSON.stringify(payload)); } catch (e) { // eslint-disable-next-line console.error(e); diff --git a/v2/internal/frontend/runtime/desktop/events.js b/v2/internal/frontend/runtime/desktop/events.js index d7bf2c905..06b709781 100644 --- a/v2/internal/frontend/runtime/desktop/events.js +++ b/v2/internal/frontend/runtime/desktop/events.js @@ -9,8 +9,6 @@ The lightweight framework for web-like apps */ /* jshint esversion: 6 */ -import {SendMessage} from './ipc'; - // Defines a single listener with a maximum number of times to callback /** @@ -152,7 +150,7 @@ export function EventsEmit(eventName) { notifyListeners(payload); // Notify Go listeners - SendMessage('EE' + JSON.stringify(payload)); + window.WailsInvoke('EE' + JSON.stringify(payload)); } export function EventsOff(eventName) { @@ -160,5 +158,5 @@ export function EventsOff(eventName) { eventListeners.delete(eventName); // Notify Go listeners - SendMessage('EX' + eventName); + window.WailsInvoke('EX' + eventName); } \ No newline at end of file diff --git a/v2/internal/frontend/runtime/desktop/ipc.js b/v2/internal/frontend/runtime/desktop/ipc.js index e28f7d2ee..9652205c9 100644 --- a/v2/internal/frontend/runtime/desktop/ipc.js +++ b/v2/internal/frontend/runtime/desktop/ipc.js @@ -9,23 +9,12 @@ The lightweight framework for web-like apps */ /* jshint esversion: 6 */ -// IPC Listeners -const listeners = []; - -/** - * Adds a listener to IPC messages - * @param {function} callback - */ -export function AddIPCListener(callback) { - listeners.push(callback); -} - /** * SendMessage sends the given message to the backend * * @param {string} message */ -export function SendMessage(message) { +window.WailsInvoke = function (message) { // Call Platform specific invoke method if (PLATFORM === "windows") { @@ -35,11 +24,4 @@ export function SendMessage(message) { } else { console.error("Unsupported Platform"); } - - // Also send to listeners - if (listeners.length > 0) { - for (let i = 0; i < listeners.length; i++) { - listeners[i](message); - } - } -} +}; diff --git a/v2/internal/frontend/runtime/desktop/log.js b/v2/internal/frontend/runtime/desktop/log.js index ed045f12c..7f81cac23 100644 --- a/v2/internal/frontend/runtime/desktop/log.js +++ b/v2/internal/frontend/runtime/desktop/log.js @@ -10,8 +10,6 @@ The lightweight framework for web-like apps /* jshint esversion: 6 */ -import {SendMessage} from './ipc'; - /** * Sends a log message to the backend with the given level + message * @@ -22,7 +20,7 @@ function sendLogMessage(level, message) { // Log Message format: // l[type][message] - SendMessage('L' + level + message); + window.WailsInvoke('L' + level + message); } /** diff --git a/v2/internal/frontend/runtime/desktop/main.js b/v2/internal/frontend/runtime/desktop/main.js index 570552104..4fb1cdced 100644 --- a/v2/internal/frontend/runtime/desktop/main.js +++ b/v2/internal/frontend/runtime/desktop/main.js @@ -12,8 +12,6 @@ import * as Log from './log'; import {EventsEmit, EventsNotify, EventsOff, EventsOn, EventsOnce, EventsOnMultiple} from './events'; import {Callback} from './calls'; import {SetBindings} from "./bindings"; -// import {AddScript, DisableDefaultContextMenu, InjectCSS} from './utils'; -import {SendMessage} from './ipc'; // Backend is where the Go struct wrappers get bound to window.backend = {}; @@ -35,8 +33,8 @@ window.wails = { }; window.wails.SetBindings(window.wailsbindings); -delete window.wails['SetBindings']; -delete window['wailsbindings']; +delete window.wails.SetBindings; +delete window.wailsbindings; // Setup drag handler // Based on code from: https://github.com/patr0nus/DeskGap @@ -46,7 +44,7 @@ window.addEventListener('mousedown', (e) => { if (currentElement.hasAttribute('data-wails-no-drag')) { break; } else if (currentElement.hasAttribute('data-wails-drag')) { - SendMessage("drag"); + window.WailsInvoke("drag"); break; } currentElement = currentElement.parentElement; diff --git a/v2/internal/frontend/runtime/ipc_dev.go b/v2/internal/frontend/runtime/ipc_dev.go new file mode 100644 index 000000000..7d70f00ab --- /dev/null +++ b/v2/internal/frontend/runtime/ipc_dev.go @@ -0,0 +1,8 @@ +//go:build dev + +package runtime + +import _ "embed" + +//go:embed ipc_dev.js +var IPCJS []byte diff --git a/v2/internal/frontend/runtime/ipc_windows.go b/v2/internal/frontend/runtime/ipc_windows.go new file mode 100644 index 000000000..86151d21c --- /dev/null +++ b/v2/internal/frontend/runtime/ipc_windows.go @@ -0,0 +1,8 @@ +//go:build desktop && windows + +package runtime + +import _ "embed" + +//go:embed ipc_windows.js +var IPCJS []byte diff --git a/v2/internal/frontend/runtime/package.json b/v2/internal/frontend/runtime/package.json index 7e0aaf2b1..d77244b9f 100644 --- a/v2/internal/frontend/runtime/package.json +++ b/v2/internal/frontend/runtime/package.json @@ -5,8 +5,10 @@ "main": "index.js", "scripts": { "build": "run-p build:*", - "build:windows": "esbuild desktop/main.js --bundle --minify --outfile=runtime_production_windows.js --define:PLATFORM='windows'", - "build:windows-dev": "esbuild desktop/main.js --bundle --sourcemap=inline --outfile=runtime_debug_windows.js --define:PLATFORM='windows'", + "build:ipc-windows": "esbuild desktop/ipc.js --bundle --minify --outfile=ipc_windows.js --define:PLATFORM='windows'", + "build:ipc-dev": "esbuild desktop/ipc.js --bundle --minify --outfile=ipc_dev.js", + "build:runtime-desktop-prod": "esbuild desktop/main.js --bundle --minify --outfile=runtime_prod_desktop.js", + "build:runtime-desktop-debug": "esbuild desktop/main.js --bundle --sourcemap=inline --outfile=runtime_debug_desktop.js", "test": "echo \"Error: no test specified\" && exit 1" }, "author": "Lea Anthony ", diff --git a/v2/internal/frontend/runtime/runtime_debug_desktop.go b/v2/internal/frontend/runtime/runtime_debug_desktop.go new file mode 100644 index 000000000..b76d37ff0 --- /dev/null +++ b/v2/internal/frontend/runtime/runtime_debug_desktop.go @@ -0,0 +1,8 @@ +//go:build debug && desktop + +package runtime + +import _ "embed" + +//go:embed runtime_debug_desktop.js +var RuntimeJS []byte diff --git a/v2/internal/frontend/runtime/runtime_debug_windows.go b/v2/internal/frontend/runtime/runtime_debug_windows.go deleted file mode 100644 index 7c3a0db6c..000000000 --- a/v2/internal/frontend/runtime/runtime_debug_windows.go +++ /dev/null @@ -1,9 +0,0 @@ -//+build debug -//+build windows - -package runtime - -import _ "embed" - -//go:embed runtime_debug_windows.js -var RuntimeJS string diff --git a/v2/internal/frontend/runtime/runtime_prod_desktop.go b/v2/internal/frontend/runtime/runtime_prod_desktop.go new file mode 100644 index 000000000..0f70269c6 --- /dev/null +++ b/v2/internal/frontend/runtime/runtime_prod_desktop.go @@ -0,0 +1,8 @@ +//go:build production && desktop + +package runtime + +import _ "embed" + +//go:embed runtime_prod_desktop.js +var RuntimeJS []byte diff --git a/v2/internal/frontend/runtime/runtime_production_windows.go b/v2/internal/frontend/runtime/runtime_production_windows.go deleted file mode 100644 index 177aaadba..000000000 --- a/v2/internal/frontend/runtime/runtime_production_windows.go +++ /dev/null @@ -1,9 +0,0 @@ -//+build !debug -//+build windows - -package runtime - -import _ "embed" - -//go:embed runtime_production_windows.js -var RuntimeJS string