@wailsio/runtime 3.0.0-alpha.21 → 3.0.0-alpha.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wailsio/runtime",
-  "version": "3.0.0-alpha.21",
+  "version": "3.0.0-alpha.23",
   "description": "Wails Runtime",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -27,5 +27,8 @@
     "typedoc": "^0.25.7",
     "typedoc-plugin-markdown": "^3.17.1",
     "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "nanoid": "^5.0.7"
   }
 }

package/src/calls.js

@@ -113,7 +113,7 @@ function callBinding(type, options = {}) {
             queuedCancel = true;
         }
     };
-    
+
     return p;
 }
 
@@ -130,19 +130,13 @@ export function Call(options) {
 /**
  * Executes a method by name.
  *
- * @param {string} name - The name of the method in the format 'package.struct.method'.
+ * @param {string} methodName - The name of the method in the format 'package.struct.method'.
  * @param {...*} args - The arguments to pass to the method.
  * @throws {Error} If the name is not a string or is not in the correct format.
  * @returns {*} The result of the method execution.
  */
-export function ByName(name, ...args) {
-    if (typeof name !== "string" || name.split(".").length !== 3) {
-        throw new Error("CallByName requires a string in the format 'package.struct.method'");
-    }
-    let [packageName, structName, methodName] = name.split(".");
+export function ByName(methodName, ...args) {
     return callBinding(CallBinding, {
-        packageName,
-        structName,
         methodName,
         args
     });

package/src/create.js

@@ -0,0 +1,125 @@
+/*
+ _	   __	  _ __
+| |	 / /___ _(_) /____
+| | /| / / __ `/ / / ___/
+| |/ |/ / /_/ / / (__  )
+|__/|__/\__,_/_/_/____/
+The electron alternative for Go
+(c) Lea Anthony 2019-present
+*/
+
+/* jshint esversion: 9 */
+
+/**
+ * Any is a dummy creation function for simple or unknown types.
+ * @template T
+ * @param {any} source
+ * @returns {T}
+ */
+export function Any(source) {
+    return /** @type {T} */(source);
+}
+
+/**
+ * ByteSlice is a creation function that replaces
+ * null strings with empty strings.
+ * @param {any} source
+ * @returns {string}
+ */
+export function ByteSlice(source) {
+    return /** @type {any} */((source == null) ? "" : source);
+}
+
+/**
+ * Array takes a creation function for an arbitrary type
+ * and returns an in-place creation function for an array
+ * whose elements are of that type.
+ * @template T
+ * @param {(any) => T} element
+ * @returns {(any) => T[]}
+ */
+export function Array(element) {
+    if (element === Any) {
+        return (source) => (source === null ? [] : source);
+    }
+
+    return (source) => {
+        if (source === null) {
+            return [];
+        }
+        for (let i = 0; i < source.length; i++) {
+            source[i] = element(source[i]);
+        }
+        return source;
+    };
+}
+
+/**
+ * Map takes creation functions for two arbitrary types
+ * and returns an in-place creation function for an object
+ * whose keys and values are of those types.
+ * @template K, V
+ * @param {(any) => K} key
+ * @param {(any) => V} value
+ * @returns {(any) => { [_: K]: V }}
+ */
+export function Map(key, value) {
+    if (value === Any) {
+        return (source) => (source === null ? {} : source);
+    }
+
+    return (source) => {
+        if (source === null) {
+            return {};
+        }
+        for (const key in source) {
+            source[key] = value(source[key]);
+        }
+        return source;
+    };
+}
+
+/**
+ * Nullable takes a creation function for an arbitrary type
+ * and returns a creation function for a nullable value of that type.
+ * @template T
+ * @param {(any) => T} element
+ * @returns {(any) => (T | null)}
+ */
+export function Nullable(element) {
+    if (element === Any) {
+        return Any;
+    }
+
+    return (source) => (source === null ? null : element(source));
+}
+
+/**
+ * Struct takes an object mapping field names to creation functions
+ * and returns an in-place creation function for a struct.
+ * @template {{ [_: string]: ((any) => any) }} T
+ * @template {{ [Key in keyof T]?: ReturnType<T[Key]> }} U
+ * @param {T} createField
+ * @returns {(any) => U}
+ */
+export function Struct(createField) {
+    let allAny = true;
+    for (const name in createField) {
+        if (createField[name] !== Any) {
+            allAny = false;
+            break;
+        }
+    }
+    if (allAny) {
+        return Any;
+    }
+
+    return (source) => {
+        for (const name in createField) {
+            if (name in source) {
+                source[name] = createField[name](source[name]);
+            }
+        }
+        return source;
+    };
+}

package/src/index.js

@@ -19,6 +19,7 @@ import * as Application from "./application";
 import * as Browser from "./browser";
 import * as Call from "./calls";
 import * as Clipboard from "./clipboard";
+import * as Create from "./create";
 import * as Dialogs from "./dialogs";
 import * as Events from "./events";
 import * as Flags from "./flags";
@@ -32,6 +33,7 @@ export {
     Browser,
     Call,
     Clipboard,
+    Create,
     Dialogs,
     Events,
     Flags,

package/types/create.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Any is a dummy creation function for simple or unknown types.
+ * @template T
+ * @param {any} source
+ * @returns {T}
+ */
+export function Any<T>(source: any): T;
+/**
+ * Array takes a creation function for an arbitrary type
+ * and returns an in-place creation function for an array
+ * whose elements are of that type.
+ * @template T
+ * @param {(any) => T} element
+ * @returns {(any) => T[]}
+ */
+export function Array<T>(element: (any: any) => T): (any: any) => T[];
+/**
+ * Map takes creation functions for two arbitrary types
+ * and returns an in-place creation function for an object
+ * whose keys and values are of those types.
+ * @template K, V
+ * @param {(any) => K} key
+ * @param {(any) => V} value
+ * @returns {(any) => { [_: K]: V }}
+ */
+export function Map<K, V>(key: (any: any) => K, value: (any: any) => V): (any: any) => {};
+/**
+ * Nullable takes a creation function for an arbitrary type
+ * and returns a creation function for a nullable value of that type.
+ * @template T
+ * @param {(any) => T} element
+ * @returns {(any) => (T | null)}
+ */
+export function Nullable<T>(element: (any: any) => T): (any: any) => T;
+/**
+ * Struct takes an object mapping field names to creation functions
+ * and returns an in-place creation function for a struct.
+ * @template {{ [_: string]: ((any) => any) }} T
+ * @template {{ [Key in keyof T]?: ReturnType<T[Key]> }} U
+ * @param {T} createField
+ * @returns {(any) => U}
+ */
+export function Struct<T extends {
+    [_: string]: (any: any) => any;
+}, U extends { [Key in keyof T]?: ReturnType<T[Key]>; }>(createField: T): (any: any) => U;

package/types/index.d.ts

@@ -2,6 +2,7 @@ import * as Application from "./application";
 import * as Browser from "./browser";
 import * as Call from "./calls";
 import * as Clipboard from "./clipboard";
+import * as Create from "./create";
 import * as Dialogs from "./dialogs";
 import * as Events from "./events";
 import * as Flags from "./flags";
@@ -9,4 +10,4 @@ import * as Screens from "./screens";
 import * as System from "./system";
 import Window from "./window";
 import * as WML from "./wml";
-export { Application, Browser, Call, Clipboard, Dialogs, Events, Flags, Screens, System, Window, WML };
+export { Application, Browser, Call, Clipboard, Create, Dialogs, Events, Flags, Screens, System, Window, WML };