craft-native 0.0.499 → 0.0.500

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

@@ -297,10 +297,38 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
         post { onContentSizeChanged?.invoke() }
     }
 
+    /**
+     * How far the grouped tab actions reach over the end of this list, in
+     * pixels (#523). The last row is given that much room below it, so it can
+     * be brought clear of them; the rows above still scroll behind them, and
+     * the list's own padding and viewport are as they were.
+     */
+    private var floatingCover = 0
+
+    fun setFloatingCover(cover: Int) {
+        val next = if (horizontal) 0 else max(0, cover)
+        if (next == floatingCover) return
+        floatingCover = next
+        invalidateItemDecorations()
+    }
+
+    private val floatingCoverRoom = object : ItemDecoration() {
+        override fun getItemOffsets(outRect: android.graphics.Rect, view: View, parent: RecyclerView, state: State) {
+            val position = parent.getChildAdapterPosition(view)
+            val last = state.itemCount - 1
+            if (floatingCover <= 0 || horizontal || position == NO_POSITION || last < 0) return
+            val grid = layoutManager as? GridLayoutManager
+            val endsTheList = if (grid == null) position == last
+            else grid.spanSizeLookup.getSpanGroupIndex(position, grid.spanCount) == grid.spanSizeLookup.getSpanGroupIndex(last, grid.spanCount)
+            if (endsTheList) outRect.bottom = floatingCover
+        }
+    }
+
     init {
         adapter = listAdapter
         itemAnimator = null
         addOnScrollListener(scrollListener)
+        addItemDecoration(floatingCoverRoom)
     }
 
     fun setKeyboardDismissMode(mode: String, dismissKeyboard: () -> Unit) {
@@ -387,11 +415,10 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
         }
 
         val seen = mutableMapOf<String, Int>()
+        val taken = mutableSetOf<String>()
         val next = nodes.mapIndexed { index, node ->
             val base = identity(node) ?: "index:$index"
-            val occurrence = seen.getOrDefault(base, 0)
-            seen[base] = occurrence + 1
-            val unique = if (occurrence == 0) base else "$base#$occurrence"
+            val unique = uniqueIdentity(base, seen, taken)
             val role = node.optJSONObject("props")?.optString("listRole").orEmpty()
             Item(unique, node, node.toString(), role.isNotBlank() && role != "item")
         }.let { if (inverted) it.reversed() else it }
@@ -546,6 +573,27 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
         endReached?.invoke()
     }
 
+    /**
+     * A row's identity, its own in this list.
+     *
+     * Rows that share a key are told apart by a suffix: `run`, then `run#1`.
+     * A row whose own key was `run#1` then had the identity of the second
+     * `run`, and with it the same stable id, which a RecyclerView requires to
+     * be unique; UIKit's list ended the process on the same rows. The suffix
+     * counts on until the identity is one no row has taken. A list with no
+     * such key has the identities it always had.
+     */
+    private fun uniqueIdentity(base: String, seen: MutableMap<String, Int>, taken: MutableSet<String>): String {
+        var occurrence = seen.getOrDefault(base, 0)
+        var identity = if (occurrence == 0) base else "$base#$occurrence"
+        while (!taken.add(identity)) {
+            occurrence += 1
+            identity = "$base#$occurrence"
+        }
+        seen[base] = occurrence + 1
+        return identity
+    }
+
     private fun identity(node: JSONObject): String? {
         val props = node.optJSONObject("props") ?: JSONObject()
         return listOf(node.optString("id"), node.optString("key"), props.optString("key"), props.optString("testID"))

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

@@ -1335,6 +1335,60 @@ internal class CraftNativeChrome(
         refreshColors()
     }
 
+    /**
+     * How far the grouped actions reach up from the tab bar, in pixels: their
+     * height and their lift above it. Zero when they are not floating over
+     * the screen (no group, a hidden bar, or actions that sit in the tab row).
+     */
+    internal fun floatingActionsReach(): Int =
+        if (accessoryGroup.parent === body && accessoryGroup.visibility == View.VISIBLE && accessoryGroup.height > 0) (body.height - accessoryGroup.top).coerceAtLeast(0)
+        else 0
+
+    private var floatingClearancePosted = false
+    private var floatingClearanceGiven = false
+
+    /**
+     * The grouped actions float over the trailing end of whatever scrolls
+     * behind them, and nothing was reserved, so the last rows of a screen
+     * could not be brought out from under them (#523). Every vertical scroll
+     * view and list that reaches into them is given that much room at its
+     * end; one that ends above them gets none. Measured after each layout,
+     * where each of them now ends.
+     */
+    private fun clearFloatingActions() {
+        val reach = floatingActionsReach()
+        // Nothing floats and nothing was given room: no screen to walk.
+        if (reach <= 0 && !floatingClearanceGiven) return
+        floatingClearanceGiven = reach > 0
+        val top = body.height - reach
+        val origin = IntArray(2).also { body.getLocationInWindow(it) }
+        val at = IntArray(2)
+        fun cover(view: View): Int {
+            if (reach <= 0 || !view.isLaidOut) return 0
+            view.getLocationInWindow(at)
+            return (at[1] - origin[1] + view.height - top).coerceIn(0, reach)
+        }
+        fun visit(view: View) {
+            when (view) {
+                is CraftNativeFlatList -> view.setFloatingCover(cover(view))
+                is CraftNativeScrollView -> { view.setFloatingCover(cover(view)); visit(view.content) }
+                is ViewGroup -> for (index in 0 until view.childCount) visit(view.getChildAt(index))
+            }
+        }
+        visit(content)
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        super.onLayout(changed, left, top, right, bottom)
+        if (floatingClearancePosted) return
+        floatingClearancePosted = true
+        // After this pass: giving a scroll view room asks for a layout.
+        post {
+            floatingClearancePosted = false
+            clearFloatingActions()
+        }
+    }
+
     /** The same actions and popup anchors survive switching between grouped and separate chrome. */
     private fun layoutAccessoryGroup(hidden: Boolean) {
         val layout = accessorySpec?.optString("layout").orEmpty()

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
@@ -6802,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)

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/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.499";
+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;