craft-native 0.0.497 → 0.0.500

package/dist/android/templates/MainActivityNative.kt.template

@@ -3067,6 +3067,19 @@ internal class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(cont
         }
     }
 
+    /**
+     * How far the grouped tab actions reach over the end of this scroll view,
+     * in pixels (#523). Its content gets that much room at the end, so the
+     * last of it can be brought clear of them; the rest still scrolls behind
+     * them, in the viewport it had.
+     */
+    fun setFloatingCover(cover: Int) {
+        val next = if (horizontalMode == true) 0 else max(0, cover)
+        if (vertical.paddingBottom == next) return
+        vertical.clipToPadding = false
+        vertical.setPadding(vertical.paddingLeft, vertical.paddingTop, vertical.paddingRight, next)
+    }
+
     private var bounces = true
     private var alwaysBounceVertical = true
     private var alwaysBounceHorizontal = true
@@ -3585,6 +3598,17 @@ private class CraftNativeTextField(context: Context) : EditText(context) {
         CraftNativePointers.dispatch(this, event) { super.dispatchTouchEvent(it) }
 
     companion object { val CLEAR_ACTION_ID = View.generateViewId() }
+    /**
+     * `autoFocus` as this field was last drawn. Focus is taken when it turns
+     * on, which mounting with it on is, and not on each render while it stays
+     * on: that took the keyboard back whenever anything else changed (#511).
+     */
+    private var autoFocus = false
+    fun autoFocusTurnedOn(wanted: Boolean): Boolean {
+        val turnedOn = wanted && !autoFocus
+        autoFocus = wanted
+        return turnedOn
+    }
     var clearButtonMode = "never"
     var onClearRequest: (() -> Unit)? = null
     private var clearPressed = false
@@ -5635,7 +5659,8 @@ class MainActivity : AppCompatActivity() {
             if (activeScreen.active) send(activeScreen, "SOUND_EVENT", payload)
         }
         screen = activeScreen
-        CraftNativeHub.register(activeScreen.capabilityScope) { type, payload ->
+        // Not able to hear yet: its prelude is built and run below.
+        CraftNativeHub.registerWaiting(activeScreen.capabilityScope) { type, payload ->
             if (activeScreen.active) send(activeScreen, type, payload)
         }
         if (!headless) {
@@ -5845,6 +5870,9 @@ class MainActivity : AppCompatActivity() {
             if (!activeScreen.active) return@addListener
             try {
                 setup.get()
+                // The prelude has run, so the isolate can hear: what changed
+                // while it was being built, before the bundle reads any of it.
+                CraftNativeHub.ready(activeScreen.capabilityScope)
                 val source = CraftNativeBundle.source(this, route)
                 if (source == null) {
                     if (activeScreen.active) showError("Missing native-screen.js. Build with --native-bundle after compiling STX.")
@@ -5891,6 +5919,8 @@ class MainActivity : AppCompatActivity() {
                     }
                 }, executor)
             } catch (error: Exception) {
+                // Nothing will run in this isolate, so nothing is kept for it.
+                CraftNativeHub.ready(activeScreen.capabilityScope)
                 Log.e(TAG, "Native STX bridge failed", error)
                 showError("Native STX bridge failed: ${error.message}")
             }
@@ -6796,7 +6826,7 @@ class MainActivity : AppCompatActivity() {
                     send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("text", text.toString())))
                     true
                 }
-                if (craftNativeBoolean(props.opt("autoFocus")) && !isFocused) post {
+                if (autoFocusTurnedOn(craftNativeBoolean(props.opt("autoFocus"))) && !isFocused) post {
                     if (!isFocused) {
                         requestFocus()
                         (getSystemService(INPUT_METHOD_SERVICE) as? android.view.inputmethod.InputMethodManager)
@@ -8723,9 +8753,13 @@ class MainActivity : AppCompatActivity() {
             }
             "pause" -> completion(CraftNativeCapabilityResult(data = screen.sounds.pause(id)))
             "resume" -> completion(CraftNativeCapabilityResult(data = screen.sounds.resume(id)))
-            "setVolume" -> completion(CraftNativeCapabilityResult(data = screen.sounds.setVolume(id, args.optDouble(1, Double.NaN), args.optJSONObject(2)?.optDouble("fade", 0.0) ?: 0.0)))
-            "stop" -> completion(CraftNativeCapabilityResult(data = screen.sounds.stop(id, args.optJSONObject(1)?.optDouble("fadeOut", 0.0) ?: 0.0)))
-            "stopAll" -> completion(CraftNativeCapabilityResult(data = screen.sounds.stopAll(args.optJSONObject(0)?.optDouble("fadeOut", 0.0) ?: 0.0)))
+            // A number is a JSON number: `optDouble` also read "0.5" as one,
+            // where UIKit answers false for a volume given as text.
+            "setVolume" -> completion(CraftNativeCapabilityResult(data = screen.sounds.setVolume(id,
+                (args.opt(1) as? Number)?.toDouble() ?: Double.NaN,
+                (args.optJSONObject(2)?.opt("fade") as? Number)?.toDouble() ?: 0.0)))
+            "stop" -> completion(CraftNativeCapabilityResult(data = screen.sounds.stop(id, screen.sounds.fadeOut(args.optJSONObject(1)))))
+            "stopAll" -> completion(CraftNativeCapabilityResult(data = screen.sounds.stopAll(screen.sounds.fadeOut(args.optJSONObject(0)))))
             else -> completion(CraftNativeCapabilityResult(code = "UNKNOWN_ACTION", message = "Unsupported Audio method"))
         }
     }
@@ -8865,15 +8899,8 @@ class MainActivity : AppCompatActivity() {
             else -> CraftNativeCapabilityResult(code = "UNKNOWN_ACTION", message = "Unsupported native API")
         }
 
-    internal fun deepLinkData(uri: android.net.Uri): JSONObject = JSONObject()
-        .put("url", uri.toString())
-        .put("scheme", uri.scheme ?: "")
-        .put("host", uri.host ?: "")
-        .put("path", uri.path ?: "")
-        .put("query", uri.query ?: "")
-        .put("queryParams", JSONObject().apply {
-            uri.queryParameterNames.forEach { name -> put(name, uri.getQueryParameter(name) ?: "") }
-        })
+    /** A link as the screens hear it: `CraftAppLinks.describe`, which the page bridge uses too. */
+    internal fun deepLinkData(uri: android.net.Uri): JSONObject = CraftAppLinks.describe(uri)
 
     /** App-wide news (the app's state, a link): every screen and the app script hear it. */
     private fun publish(type: String, payload: JSONObject) {
@@ -9423,6 +9450,7 @@ class MainActivity : AppCompatActivity() {
         screen.capabilityTimeouts.clear()
         screen.pendingCapabilities.forEach(capabilities::cancel)
         screen.pendingCapabilities.clear()
+        capabilities.endScope(screen.capabilityScope)
         releaseViewState(screen, retainedViews(screen).toList())
         screen.inputWatchers.forEach { (input, watcher) -> input.removeTextChangedListener(watcher) }
         screen.inputWatchers.clear()
@@ -9463,6 +9491,8 @@ class MainActivity : AppCompatActivity() {
             screen.capabilityTimeouts.clear()
             screen.pendingCapabilities.forEach(capabilities::cancel)
             screen.pendingCapabilities.clear()
+            // Again: a transaction can be begun while the isolate is closing.
+            capabilities.endScope(screen.capabilityScope)
             done()
         }
     }

package/dist/api/process.d.ts

@@ -60,7 +60,6 @@ export declare function exec(command: string, options?: ExecOptions): Promise<Ex
  */
 export interface SpawnOptions {
     cwd?: string;
-    env?: Record<string, string>;
     /**
      * Run `command` as a command line through a shell (cmd.exe on Windows,
      * /bin/sh elsewhere) instead of executing it directly.
@@ -74,45 +73,41 @@ export interface SpawnOptions {
      */
     shell?: boolean;
 }
+/**
+ * A process started through the native bridge.
+ *
+ * What native `shell.spawn` does, and so all this class offers: start a
+ * program, and kill it. The child inherits Craft's own standard output and
+ * error. Nothing it writes is delivered to the page, and its exit is not
+ * reported.
+ *
+ * `onStdout`, `onStderr`, `onExit` and `write` used to be declared here. No
+ * native bridge ever emitted the events behind them or accepted input, so a
+ * handler registered with them was never called. They are removed rather than
+ * left as methods that accept a callback and stay silent. To read a child's
+ * output, run it in your app's backend process and send the result to the
+ * page; `exec()` covers a command that finishes and returns its output whole.
+ *
+ * Windows and Linux desktop builds do not serve the `shell` namespace at all:
+ * there `start()` rejects.
+ */
 export declare class ChildProcess {
     private command;
     private args;
     private options;
     private processId;
-    private onStdoutHandlers;
-    private onStderrHandlers;
-    private onExitHandlers;
-    private domListeners;
-    private exited;
     constructor(command: string, args?: string[], options?: SpawnOptions);
-    private addDomListener;
-    private removeDomListeners;
-    /** Pid assigned by the native bridge, or null before start(). */
+    /** Identifier this process is registered under, or null before start(). */
     get pid(): string | null;
     /**
-     * Start the process
+     * Start the process. Resolves once native has started it.
      */
     start(): Promise<void>;
     /**
-     * Write to stdin
-     */
-    write(data: string): Promise<void>;
-    /**
-     * Kill the process
-     */
-    kill(signal?: string): Promise<void>;
-    /**
-     * Listen for stdout data
-     */
-    onStdout(handler: (data: string) => void): () => void;
-    /**
-     * Listen for stderr data
-     */
-    onStderr(handler: (data: string) => void): () => void;
-    /**
-     * Listen for exit
+     * Kill the process. Native sends the platform's default termination; there
+     * is no signal to choose.
      */
-    onExit(handler: (code: number) => void): () => void;
+    kill(): Promise<void>;
 }
 /**
  * Spawn a child process

package/dist/bridge/core.d.ts

@@ -46,6 +46,12 @@ export declare const BridgeErrorCodes: {
     readonly PROTOCOL_MISMATCH: -8;
     /** Bridge transitioned from connected to disconnected with requests in flight */
     readonly DISCONNECTED: -9;
+    /**
+     * The native side received the request and refused or failed it. Not
+     * retried: asking again gets the same answer. `data.nativeCode` carries
+     * the bridge's own string code when it sent one.
+     */
+    readonly NATIVE_ERROR: -10;
 };
 export type BridgeErrorCode = typeof BridgeErrorCodes[keyof typeof BridgeErrorCodes];
 /**
@@ -136,12 +142,12 @@ export declare class NativeBridge extends EventEmitter {
      * BridgeError(PROTOCOL_MISMATCH) if the native side reports a version we
      * don't speak.
      *
-     * This is **opt-in** — you must call it explicitly. It assumes the host
-     * registers a `_handshake` handler; the Zig core's
-     * `Bridge.registerDefaults()` does this for you. If you're embedding Craft
-     * inside a host that hasn't wired `_handshake`, do not call this method
-     * (the timeout path will reject with TIMEOUT, which is louder than a
-     * silent mismatch but still a failure).
+     * This is **opt-in** — you must call it explicitly, and only against a
+     * host of your own that answers a `_handshake` request. Craft's own
+     * webview hosts do not: inside one, requests go through
+     * `window.craft.invoke`, which takes `namespace.action` names, and this
+     * call is rejected immediately instead of negotiating anything. Use
+     * `window.craft.capabilities` to ask a Craft host what it serves.
      */
     handshake(): Promise<{
         nativeVersion: number;
@@ -203,6 +209,24 @@ export declare class NativeBridge extends EventEmitter {
      * use that to fail fast instead of waiting for the request timeout.
      */
     private send;
+    /**
+     * Hand a request to `window.craft.invoke`, the dispatcher that
+     * `craft-bridge.js` injects into every Craft webview, and settle the
+     * pending entry with what native answers.
+     *
+     * This is the only path by which `request()` reaches native code. The
+     * `{id, type: 'request', method, params}` envelope this class builds is not
+     * something any Craft host parses: posted raw to the `craft` message
+     * handler it was dropped, and every `request()` waited out its timeout and
+     * its retries. The method name is used as written, `namespace.action`, so
+     * it has to be one the native bridge serves (`fs.readFile`,
+     * `shell.openUrl`, `dialog.openFile`); one it does not serve is rejected
+     * with `NATIVE_ERROR` straight away.
+     *
+     * Returns false when the injected bridge is not present, so the older
+     * transports below still get their turn in a host that provides one.
+     */
+    private sendThroughInjectedBridge;
     /**
      * Reject the pending entry corresponding to `message.id` with `error`,
      * if any. Used by `send()` when serialization or transport throws so

package/dist/browser.js

@@ -909,8 +909,24 @@ async function createBrowserPlatform(options = {}) {
         }
         if (method === "write") {
           const settings = object(args[2]);
-          const contents = settings.encoding === "base64" ? Uint8Array.from(atob(String(args[1])), (letter) => letter.charCodeAt(0)) : String(args[1]);
-          return file([contents], String(args[0]), String(settings.type ?? "application/octet-stream"));
+          const [name, data] = args;
+          const refuse = (message) => Object.assign(new Error(message), { code: "INVALID_ARGUMENT" });
+          if (typeof name !== "string" || !name.trim())
+            throw refuse("files.write needs a file name");
+          if (typeof data !== "string")
+            throw refuse("files.write needs its contents as a string");
+          const encoding = settings.encoding ?? "utf8";
+          if (encoding !== "utf8" && encoding !== "base64")
+            throw refuse("files.write encoding is 'utf8' or 'base64'");
+          let contents = data;
+          if (encoding === "base64") {
+            try {
+              contents = Uint8Array.from(atob(data), (letter) => letter.charCodeAt(0));
+            } catch {
+              throw refuse("files.write base64 is invalid");
+            }
+          }
+          return file([contents], name, String(settings.type ?? "application/octet-stream"));
         }
         if (method === "remove") {
           const path = String(args[0]);
@@ -1071,14 +1087,15 @@ async function createBrowserPlatform(options = {}) {
             throw error;
           }
         }
+        const fadeOut = (options) => typeof options.fadeOut === "number" ? options.fadeOut : 0;
         if (method === "stopAll") {
           soundRequests.clear();
-          await Promise.all([...sounds.keys()].map((key) => stopSound(key, Number(first.fadeOut ?? 0))));
+          await Promise.all([...sounds.keys()].map((key) => stopSound(key, fadeOut(first))));
           return true;
         }
         if (method === "stop") {
           soundRequests.delete(id);
-          await stopSound(id, Number(object(args[1]).fadeOut ?? 0));
+          await stopSound(id, fadeOut(object(args[1])));
           return Boolean(sound);
         }
         if (!sound)
@@ -1092,7 +1109,12 @@ async function createBrowserPlatform(options = {}) {
           return true;
         }
         if (method === "setVolume") {
-          await fade(sound, Number(args[1]), Number(object(args[2]).fade ?? 0));
+          const volume = args[1];
+          const asked = object(args[2]).fade;
+          const milliseconds = typeof asked === "number" ? asked : 0;
+          if (typeof volume !== "number" || !Number.isFinite(volume) || !Number.isFinite(milliseconds) || milliseconds < 0)
+            return false;
+          await fade(sound, volume, milliseconds);
           return true;
         }
       }

package/dist/cli.js

@@ -1395,6 +1395,33 @@ Description: ${description || opts.name}
     }
   });
 }
+function rpmSpec(options) {
+  return [
+    "%global debug_package %{nil}",
+    "%global _build_id_links none",
+    "%global __strip /bin/true",
+    "%global __os_install_post %{nil}",
+    `Name: ${options.name}`,
+    `Version: ${options.version}`,
+    "Release: 1",
+    `Summary: ${options.summary}`,
+    "License: MIT",
+    `Source0: ${options.name}`,
+    ...options.requires ? [`Requires: ${options.requires}`] : [],
+    "",
+    "%description",
+    options.description,
+    "",
+    "%install",
+    "mkdir -p %{buildroot}/usr/bin",
+    `install -m 755 %{SOURCE0} %{buildroot}/usr/bin/${options.name}`,
+    "",
+    "%files",
+    `/usr/bin/${options.name}`,
+    ""
+  ].join(`
+`);
+}
 async function createRPM(opts) {
   return new Promise((resolve) => {
     try {
@@ -1427,26 +1454,17 @@ async function createRPM(opts) {
         return r;
       }).join(", ");
       copyFileSync(opts.binaryPath, join3(sourcesDir, sanitizedName));
-      const specContent = `Name: ${sanitizedName}
-Version: ${opts.version}
-Release: 1%{?dist}
-Summary: ${summary}
-License: MIT
-Requires: ${requires}
-
-%description
-${description}
-
-%install
-mkdir -p %{buildroot}/usr/bin
-install -m 755 %{SOURCE0} %{buildroot}/usr/bin/${sanitizedName}
-
-%files
-/usr/bin/${sanitizedName}
-`;
+      const specContent = rpmSpec({ name: sanitizedName, version: opts.version, summary, description, requires });
       const specPath = join3(specDir, `${opts.name.toLowerCase()}.spec`);
       writeFileSync4(specPath, specContent);
       const proc = spawn("rpmbuild", ["-bb", specPath]);
+      let said = "";
+      proc.stdout?.on("data", (chunk) => {
+        said += chunk.toString();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        said += chunk.toString();
+      });
       proc.on("close", (code) => {
         if (code === 0) {
           const rpmName = `${opts.name.toLowerCase()}-${opts.version}-1.x86_64.rpm`;
@@ -1458,7 +1476,9 @@ install -m 755 %{SOURCE0} %{buildroot}/usr/bin/${sanitizedName}
             resolve({ success: false, error: "Failed to copy built RPM" });
           }
         } else {
-          resolve({ success: false, error: `rpmbuild exited with code ${code}` });
+          resolve({ success: false, error: `rpmbuild exited with code ${code}: ${said.trim().split(`
+`).slice(-12).join(`
+`)}` });
         }
       });
       proc.on("error", (err) => {
@@ -3246,7 +3266,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.497";
+var version = "0.0.500";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/components/index.d.ts

@@ -801,7 +801,7 @@ export interface TextInputProps extends BaseProps {
     autoCapitalize?: 'none' | 'sentences' | 'words' | 'characters';
     /** Auto correct */
     autoCorrect?: boolean;
-    /** Auto focus */
+    /** Focus the input when it mounts, or when this turns on; not on each render. */
     autoFocus?: boolean;
     /** Secure text entry (password) */
     secureTextEntry?: boolean;