peachsim 0.1.939 → 0.1.1399

package/dist-lib/worklet-executable.mjs

@@ -1,55 +1,270 @@
-/*! rnx v0.1.939 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! peach v0.1.1399 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 
 // src/worklet-executable.ts
 import { parse } from "acorn";
 function isNode(value) {
   return value !== null && typeof value === "object" && typeof Reflect.get(value, "type") === "string";
 }
-function walk(node, visit) {
-  visit(node);
-  for (const value of Object.values(node)) {
-    if (isNode(value)) walk(value, visit);
-    else if (Array.isArray(value)) {
-      for (const child of value) if (isNode(child)) walk(child, visit);
-    }
-  }
+function childNodes(value) {
+  return Array.isArray(value) ? value.filter(isNode) : [];
+}
+function identifierName(node) {
+  if (!isNode(node) || node.type !== "Identifier") return void 0;
+  const name = Reflect.get(node, "name");
+  return typeof name === "string" ? name : void 0;
 }
 function propertyName(node) {
   if (!isNode(node)) return void 0;
   const name = Reflect.get(node, node.type === "Identifier" ? "name" : "value");
   return typeof name === "string" ? name : void 0;
 }
-function workletExecutableBodies(syntax) {
-  if (!isNode(syntax)) throw new Error("peach: expected worklet syntax");
-  const tree = syntax;
-  const initNames = /* @__PURE__ */ new Set();
-  const objects = /* @__PURE__ */ new Set();
-  walk(tree, (node) => {
-    if (node.type !== "AssignmentExpression") return;
-    const left = Reflect.get(node, "left");
-    if (!isNode(left) || left.type !== "MemberExpression" || propertyName(Reflect.get(left, "property")) !== "__initData")
+function keyName(owner, key) {
+  if (Reflect.get(owner, "computed") === true && isNode(key) && key.type === "Identifier")
+    return void 0;
+  return propertyName(key);
+}
+function patternNames(node) {
+  if (!isNode(node)) return [];
+  switch (node.type) {
+    case "Identifier": {
+      const name = identifierName(node);
+      return name === void 0 ? [] : [name];
+    }
+    case "AssignmentPattern":
+      return patternNames(Reflect.get(node, "left"));
+    case "RestElement":
+      return patternNames(Reflect.get(node, "argument"));
+    case "ArrayPattern":
+      return childNodes(Reflect.get(node, "elements")).flatMap(patternNames);
+    case "ObjectPattern":
+      return childNodes(Reflect.get(node, "properties")).flatMap(
+        (property) => patternNames(
+          property.type === "Property" || property.type === "ObjectProperty" ? Reflect.get(property, "value") : property
+        )
+      );
+    default:
+      return [];
+  }
+}
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+var MAX_RESOLUTION_DEPTH = 32;
+function newScope(parent, hoist) {
+  return { parent, hoist, names: /* @__PURE__ */ new Map() };
+}
+function hoistScope(scope) {
+  let current = scope;
+  while (!current.hoist && current.parent) current = current.parent;
+  return current;
+}
+function declare(scope, name, binding) {
+  scope.names.set(name, scope.names.has(name) ? { kind: "opaque" } : binding);
+}
+function declareOpaque(scope, names) {
+  for (const name of names) declare(scope, name, { kind: "opaque" });
+}
+function lookup(scope, name) {
+  for (let current = scope; current; current = current.parent) {
+    const binding = current.names.get(name);
+    if (binding) return binding;
+  }
+  return void 0;
+}
+function declareParam(inner, fn, index, param) {
+  const name = identifierName(param);
+  if (name !== void 0) {
+    declare(inner, name, { kind: "param", fn, index });
+    return;
+  }
+  if (!isNode(param) || param.type !== "ObjectPattern") {
+    declareOpaque(inner, patternNames(param));
+    return;
+  }
+  for (const property of childNodes(Reflect.get(param, "properties"))) {
+    const key = keyName(property, Reflect.get(property, "key"));
+    const value = Reflect.get(property, "value");
+    const valueName = identifierName(value);
+    if (key !== void 0 && valueName !== void 0 && ["Property", "ObjectProperty"].includes(property.type))
+      declare(inner, valueName, { kind: "param", fn, index, key });
+    else
+      declareOpaque(
+        inner,
+        patternNames(property.type === "RestElement" ? property : value)
+      );
+  }
+}
+function enter(node, scope) {
+  switch (node.type) {
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression": {
+      const inner = newScope(scope, true);
+      const params = Reflect.get(node, "params");
+      if (Array.isArray(params)) {
+        params.forEach((param, index) => declareParam(inner, node, index, param));
+      }
+      const id = Reflect.get(node, "id");
+      if (node.type === "FunctionExpression") declareOpaque(inner, patternNames(id));
+      if (node.type === "FunctionDeclaration") {
+        declareOpaque(scope, patternNames(id));
+        declareOpaque(hoistScope(scope), patternNames(id));
+      }
+      return inner;
+    }
+    case "BlockStatement":
+    case "ForStatement":
+    case "ForInStatement":
+    case "ForOfStatement":
+    case "SwitchStatement":
+    case "StaticBlock":
+      return newScope(scope, false);
+    case "CatchClause": {
+      const inner = newScope(scope, false);
+      declareOpaque(inner, patternNames(Reflect.get(node, "param")));
+      return inner;
+    }
+    case "VariableDeclaration": {
+      const target = Reflect.get(node, "kind") === "var" ? hoistScope(scope) : scope;
+      for (const declarator of childNodes(Reflect.get(node, "declarations"))) {
+        const id = Reflect.get(declarator, "id");
+        const init = Reflect.get(declarator, "init");
+        const name = identifierName(id);
+        if (name !== void 0 && isNode(init))
+          declare(target, name, { kind: "value", init, scope });
+        else declareOpaque(target, patternNames(id));
+      }
+      return scope;
+    }
+    case "ImportDeclaration":
+      for (const specifier of childNodes(Reflect.get(node, "specifiers")))
+        declareOpaque(scope, patternNames(Reflect.get(specifier, "local")));
+      return scope;
+    case "ClassDeclaration":
+      declareOpaque(scope, patternNames(Reflect.get(node, "id")));
+      return scope;
+    default:
+      return scope;
+  }
+}
+function recordWrites(target, scope, collection) {
+  for (const name of patternNames(target)) collection.writes.push({ name, scope });
+}
+function record(node, scope, collection) {
+  switch (node.type) {
+    case "AssignmentExpression": {
+      const left = Reflect.get(node, "left");
+      const right = Reflect.get(node, "right");
+      if (isNode(left) && left.type === "MemberExpression" && keyName(left, Reflect.get(left, "property")) === "__initData" && isNode(right))
+        collection.inits.push({ value: right, scope });
+      recordWrites(left, scope, collection);
       return;
-    const right = Reflect.get(node, "right");
-    if (!isNode(right)) return;
-    if (right.type === "ObjectExpression") objects.add(right);
-    else if (right.type === "Identifier") {
-      const name = propertyName(right);
-      if (name) initNames.add(name);
     }
-  });
-  walk(tree, (node) => {
-    if (node.type !== "VariableDeclarator") return;
-    const name = propertyName(Reflect.get(node, "id"));
-    const init = Reflect.get(node, "init");
-    if (name && initNames.has(name) && isNode(init) && init.type === "ObjectExpression") {
-      objects.add(init);
+    case "UpdateExpression":
+      recordWrites(Reflect.get(node, "argument"), scope, collection);
+      return;
+    case "ForInStatement":
+    case "ForOfStatement":
+      recordWrites(Reflect.get(node, "left"), scope, collection);
+      return;
+    case "CallExpression": {
+      const callee = Reflect.get(node, "callee");
+      if (isNode(callee) && FUNCTION_TYPES.has(callee.type))
+        collection.immediate.set(callee, { call: node, scope });
+      return;
     }
-  });
+    default:
+      return;
+  }
+}
+function visit(node, scope, collection) {
+  record(node, scope, collection);
+  const inner = enter(node, scope);
+  for (const value of Object.values(node)) {
+    if (isNode(value)) visit(value, inner, collection);
+    else for (const child of childNodes(value)) visit(child, inner, collection);
+  }
+}
+function collectInitData(root) {
+  const collection = {
+    inits: [],
+    immediate: /* @__PURE__ */ new Map(),
+    writes: [],
+    reassigned: /* @__PURE__ */ new Set()
+  };
+  visit(root, newScope(void 0, true), collection);
+  for (const { name, scope } of collection.writes) {
+    const binding = lookup(scope, name);
+    if (binding) collection.reassigned.add(binding);
+  }
+  return collection;
+}
+function immediateArgument(fn, index, collection) {
+  const immediate = collection.immediate.get(fn);
+  const args = immediate && Reflect.get(immediate.call, "arguments");
+  if (!immediate || !Array.isArray(args)) return void 0;
+  const preceding = args.slice(0, index + 1);
+  if (preceding.some((arg) => isNode(arg) && arg.type === "SpreadElement"))
+    return void 0;
+  return { argument: args[index], scope: immediate.scope };
+}
+function propertyValue(object, name) {
+  let value;
+  for (const property of childNodes(Reflect.get(object, "properties"))) {
+    if (property.type === "SpreadElement") return void 0;
+    if (!["Property", "ObjectProperty"].includes(property.type)) continue;
+    if (keyName(property, Reflect.get(property, "key")) !== name) continue;
+    const next = Reflect.get(property, "value");
+    value = isNode(next) ? next : void 0;
+  }
+  return value;
+}
+function resolveProperty(owner, name, collection, depth) {
+  if (!owner) return void 0;
+  const value = propertyValue(owner.object, name);
+  return value && resolveObject(value, owner.scope, collection, depth + 1);
+}
+function resolveObject(expression, scope, collection, depth) {
+  if (depth > MAX_RESOLUTION_DEPTH) return void 0;
+  if (expression.type === "ObjectExpression") return { object: expression, scope };
+  if (expression.type === "Identifier") {
+    const name = identifierName(expression);
+    const binding = name === void 0 ? void 0 : lookup(scope, name);
+    if (!binding || collection.reassigned.has(binding)) return void 0;
+    if (binding.kind === "value")
+      return resolveObject(binding.init, binding.scope, collection, depth + 1);
+    if (binding.kind === "param") {
+      const passed = immediateArgument(binding.fn, binding.index, collection);
+      if (!passed || !isNode(passed.argument)) return void 0;
+      const argument = resolveObject(passed.argument, passed.scope, collection, depth + 1);
+      return binding.key === void 0 ? argument : resolveProperty(argument, binding.key, collection, depth);
+    }
+    return void 0;
+  }
+  if (expression.type === "MemberExpression") {
+    const name = keyName(expression, Reflect.get(expression, "property"));
+    const object = Reflect.get(expression, "object");
+    if (name === void 0 || !isNode(object)) return void 0;
+    const owner = resolveObject(object, scope, collection, depth + 1);
+    return resolveProperty(owner, name, collection, depth);
+  }
+  return void 0;
+}
+function workletExecutableBodies(syntax, includeCompiled = false) {
+  if (!isNode(syntax)) throw new Error("peach: expected worklet syntax");
+  const collection = collectInitData(syntax);
+  const objects = /* @__PURE__ */ new Set();
+  for (const { value, scope } of collection.inits) {
+    const resolved = resolveObject(value, scope, collection, 0);
+    if (resolved) objects.add(resolved.object);
+  }
   const bodies = [];
   for (const object of objects) {
     const properties = Reflect.get(object, "properties");
     if (!Array.isArray(properties)) continue;
-    if (properties.some(
+    if (!includeCompiled && properties.some(
       (property2) => isNode(property2) && propertyName(Reflect.get(property2, "key")) === "__peachExecutable"
     ))
       continue;

package/install.sh

@@ -178,7 +178,16 @@ if [ "${PEACH_NO_MODIFY_PATH:-0}" = "1" ]; then
 else
   case "${SHELL:-}" in
     */zsh) update_shell_profile "$HOME/.zshrc" zsh ;;
-    */bash) update_shell_profile "$HOME/.bashrc" bash ;;
+    */bash)
+      update_shell_profile "$HOME/.bashrc" bash
+      # bash login shells read only the first readable profile in this order.
+      for profile in "$HOME/.bash_profile" "$HOME/.bash_login" "$HOME/.profile"; do
+        if [ -r "$profile" ] || [ "$profile" = "$HOME/.profile" ]; then
+          update_shell_profile "$profile" bash
+          break
+        fi
+      done
+      ;;
     *) update_shell_profile "$HOME/.profile" "" ;;
   esac
 fi

package/kotlin/{AppSources → AndroidViewSources}/android/content/res/Resources.kt

@@ -2,14 +2,14 @@ package android.content.res
 
 import android.util.DisplayMetrics
 import dev.peach.app.javaFormat
-import dev.peach.app.peachAppArrays
-import dev.peach.app.peachAppColors
-import dev.peach.app.peachAppPlurals
-import dev.peach.app.peachAppStrings
 
 class Resources internal constructor(
     val configuration: Configuration,
     val displayMetrics: DisplayMetrics,
+    private val strings: Map<Int, Map<String, String>>,
+    private val plurals: Map<Int, Map<String, Map<String, String>>>,
+    private val arrays: Map<Int, Map<String, List<String>>>,
+    private val colors: Map<Int, IntArray>,
 ) {
     class NotFoundException(name: String) : RuntimeException(name)
 
@@ -18,7 +18,7 @@ class Resources internal constructor(
     class Theme internal constructor()
 
     fun getString(id: Int): String =
-        resolve(peachAppStrings[id]) ?: throw NotFoundException("String resource ID #0x${id.toString(16)}")
+        resolve(strings[id]) ?: throw NotFoundException("String resource ID #0x${id.toString(16)}")
 
     fun getString(id: Int, vararg formatArgs: Any?): String =
         javaFormat(configuration.localeTag, getString(id), formatArgs)
@@ -26,7 +26,7 @@ class Resources internal constructor(
     // ResourcesImpl.getQuantityText: the item the locale's plural rule
     // selects for the quantity, then the other item
     fun getQuantityString(id: Int, quantity: Int): String {
-        val items = resolve(peachAppPlurals[id])
+        val items = resolve(plurals[id])
             ?: throw NotFoundException("Plural resource ID #0x${id.toString(16)}")
         val rule = pluralRule(configuration.localeTag, quantity)
         return items[rule] ?: items["other"]
@@ -37,14 +37,14 @@ class Resources internal constructor(
         javaFormat(configuration.localeTag, getQuantityString(id, quantity), formatArgs)
 
     fun getStringArray(id: Int): Array<String> =
-        resolve(peachAppArrays[id])?.toTypedArray()
+        resolve(arrays[id])?.toTypedArray()
             ?: throw NotFoundException("String array resource ID #0x${id.toString(16)}")
 
     // the color the configuration's night mode selects, values-night over
     // values
     fun getColor(id: Int, theme: Theme?): Int {
-        val colors = peachAppColors[id] ?: throw NotFoundException("Resource ID #0x${id.toString(16)}")
-        return colors[if (configuration.isNight()) 1 else 0]
+        val values = colors[id] ?: throw NotFoundException("Resource ID #0x${id.toString(16)}")
+        return values[if (configuration.isNight()) 1 else 0]
     }
 
     @Deprecated("Use getColor(int, Theme) instead.")

package/kotlin/AndroidViewSources/android/graphics/Canvas.kt

@@ -0,0 +1,20 @@
+package android.graphics
+
+// the Android view's canvas draws into its existing native scene. module-only
+// processes carry this contract without linking a renderer.
+internal interface ViewCanvas {
+    fun drawColor(color: Int)
+    fun save(): Int
+    fun restoreToCount(count: Int)
+    fun translate(dx: Float, dy: Float)
+    fun clipRect(left: Float, top: Float, right: Float, bottom: Float): Boolean
+}
+
+class Canvas internal constructor(private val target: ViewCanvas) {
+    fun drawColor(color: Int) = target.drawColor(color)
+    fun save(): Int = target.save()
+    fun restoreToCount(saveCount: Int) = target.restoreToCount(saveCount)
+    fun translate(dx: Float, dy: Float) = target.translate(dx, dy)
+    fun clipRect(left: Float, top: Float, right: Float, bottom: Float): Boolean = target.clipRect(left, top, right, bottom)
+    fun clipRect(left: Int, top: Int, right: Int, bottom: Int): Boolean = clipRect(left.toFloat(), top.toFloat(), right.toFloat(), bottom.toFloat())
+}

package/kotlin/AndroidViewSources/android/view/View.kt

@@ -0,0 +1,211 @@
+package android.view
+
+import android.content.Context
+import android.content.res.Resources
+import android.graphics.Canvas
+
+open class View(val context: Context) {
+    val resources: Resources get() = context.resources
+    var parent: ViewGroup? = null
+        internal set
+    var layoutParams: ViewGroup.LayoutParams? = null
+    internal var attachedWindow: Any? = null
+
+    var left: Int = 0
+        private set
+    var top: Int = 0
+        private set
+    var right: Int = 0
+        private set
+    var bottom: Int = 0
+        private set
+    val width: Int get() = right - left
+    val height: Int get() = bottom - top
+    var measuredWidth: Int = 0
+        private set
+    var measuredHeight: Int = 0
+        private set
+    var minimumWidth: Int = 0
+    var minimumHeight: Int = 0
+    var paddingLeft: Int = 0
+        private set
+    var paddingTop: Int = 0
+        private set
+    var paddingRight: Int = 0
+        private set
+    var paddingBottom: Int = 0
+        private set
+    var isLayoutRequested: Boolean = true
+        private set
+    val isLaidOut: Boolean get() = laidOut
+    private var laidOut = false
+    private var skipDraw = false
+    private var backgroundColor: Int = 0
+    internal var invalidateHost: ((Boolean) -> Unit)? = null
+
+    open fun invalidate() {
+        invalidateHost?.invoke(false) ?: parent?.invalidate()
+    }
+
+    open fun requestLayout() {
+        isLayoutRequested = true
+        parent?.requestLayout() ?: invalidateHost?.invoke(true)
+    }
+
+    open fun forceLayout() { isLayoutRequested = true }
+
+    fun setWillNotDraw(willNotDraw: Boolean) { skipDraw = willNotDraw }
+    fun willNotDraw(): Boolean = skipDraw
+    fun setBackgroundColor(color: Int) { backgroundColor = color; invalidate() }
+    fun setPadding(left: Int, top: Int, right: Int, bottom: Int) {
+        paddingLeft = left; paddingTop = top; paddingRight = right; paddingBottom = bottom
+        requestLayout()
+    }
+
+    fun measure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        onMeasure(widthMeasureSpec, heightMeasureSpec)
+    }
+
+    protected open fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        setMeasuredDimension(getDefaultSize(minimumWidth, widthMeasureSpec), getDefaultSize(minimumHeight, heightMeasureSpec))
+    }
+
+    protected fun setMeasuredDimension(width: Int, height: Int) {
+        measuredWidth = width; measuredHeight = height
+    }
+
+    fun layout(l: Int, t: Int, r: Int, b: Int) {
+        val oldWidth = width
+        val oldHeight = height
+        val changed = left != l || top != t || right != r || bottom != b
+        left = l; top = t; right = r; bottom = b
+        if (oldWidth != width || oldHeight != height) onSizeChanged(width, height, oldWidth, oldHeight)
+        if (changed || isLayoutRequested) onLayout(changed, l, t, r, b)
+        isLayoutRequested = false
+        laidOut = true
+    }
+
+    protected open fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {}
+    protected open fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {}
+    protected open fun onDraw(canvas: Canvas) {}
+    protected open fun dispatchDraw(canvas: Canvas) {}
+
+    open fun draw(canvas: Canvas) {
+        if (backgroundColor != 0) canvas.drawColor(backgroundColor)
+        if (!skipDraw) onDraw(canvas)
+        dispatchDraw(canvas)
+    }
+
+    object MeasureSpec {
+        const val UNSPECIFIED = 0
+        const val EXACTLY = 0x40000000
+        const val AT_MOST = -0x80000000
+        fun makeMeasureSpec(size: Int, mode: Int): Int = (size and 0x3fffffff) or mode
+        fun getMode(spec: Int): Int = spec and -0x40000000
+        fun getSize(spec: Int): Int = spec and 0x3fffffff
+    }
+
+    companion object {
+        fun getDefaultSize(size: Int, measureSpec: Int): Int =
+            if (MeasureSpec.getMode(measureSpec) == MeasureSpec.UNSPECIFIED) size else MeasureSpec.getSize(measureSpec)
+
+        fun resolveSize(size: Int, measureSpec: Int): Int = when (MeasureSpec.getMode(measureSpec)) {
+            MeasureSpec.EXACTLY -> MeasureSpec.getSize(measureSpec)
+            MeasureSpec.AT_MOST -> minOf(size, MeasureSpec.getSize(measureSpec))
+            else -> size
+        }
+    }
+
+    val isAttachedToWindow: Boolean get() = attachedWindow != null
+
+    // view root dispatches attach through the tree once the window is added
+    internal open fun dispatchAttachedToWindow(window: Any) {
+        attachedWindow = window
+        onAttachedToWindow()
+    }
+
+    internal open fun dispatchDetachedFromWindow() {
+        onDetachedFromWindow()
+        attachedWindow = null
+    }
+
+    protected open fun onAttachedToWindow() {}
+    protected open fun onDetachedFromWindow() {}
+}
+
+open class ViewGroup(context: Context) : View(context) {
+    open class LayoutParams(val width: Int, val height: Int) {
+        companion object {
+            const val MATCH_PARENT = -1
+            const val WRAP_CONTENT = -2
+        }
+    }
+
+    init { setWillNotDraw(true) }
+
+    private val children = mutableListOf<View>()
+
+    val childCount: Int get() = children.size
+    fun getChildAt(index: Int): View? = children.getOrNull(index)
+
+    protected open fun generateDefaultLayoutParams(): LayoutParams =
+        LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)
+
+    fun addView(child: View, params: LayoutParams) {
+        child.layoutParams = params
+        addView(child)
+    }
+
+    open fun addView(child: View) {
+        check(child.parent == null) {
+            "The specified child already has a parent. You must call removeView() on the child's parent first."
+        }
+        if (child.layoutParams == null) child.layoutParams = generateDefaultLayoutParams()
+        children += child
+        child.parent = this
+        attachedWindow?.let { child.dispatchAttachedToWindow(it) }
+        requestLayout()
+    }
+
+    fun removeAllViews() {
+        for (child in children) {
+            if (child.isAttachedToWindow) child.dispatchDetachedFromWindow()
+            child.parent = null
+        }
+        children.clear()
+        requestLayout()
+    }
+
+    override fun dispatchDraw(canvas: Canvas) {
+        for (child in children) {
+            val checkpoint = canvas.save()
+            canvas.translate(child.left.toFloat(), child.top.toFloat())
+            canvas.clipRect(0f, 0f, child.width.toFloat(), child.height.toFloat())
+            child.draw(canvas)
+            canvas.restoreToCount(checkpoint)
+        }
+    }
+
+    override fun dispatchAttachedToWindow(window: Any) {
+        super.dispatchAttachedToWindow(window)
+        for (child in children.toList()) child.dispatchAttachedToWindow(window)
+    }
+
+    override fun dispatchDetachedFromWindow() {
+        for (child in children.toList()) child.dispatchDetachedFromWindow()
+        super.dispatchDetachedFromWindow()
+    }
+
+    companion object {
+        fun getChildMeasureSpec(spec: Int, padding: Int, childDimension: Int): Int {
+            if (childDimension >= 0) return MeasureSpec.makeMeasureSpec(childDimension, MeasureSpec.EXACTLY)
+            val mode = MeasureSpec.getMode(spec)
+            val size = (MeasureSpec.getSize(spec) - padding).coerceAtLeast(0)
+            return MeasureSpec.makeMeasureSpec(if (mode == MeasureSpec.UNSPECIFIED) 0 else size, when {
+                mode == MeasureSpec.UNSPECIFIED -> MeasureSpec.UNSPECIFIED
+                childDimension == LayoutParams.MATCH_PARENT && mode == MeasureSpec.EXACTLY -> MeasureSpec.EXACTLY
+                else -> MeasureSpec.AT_MOST
+            })
+        }
+    }
+}

package/kotlin/AndroidViewSources/android/widget/FrameLayout.kt

@@ -0,0 +1,61 @@
+package android.widget
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+
+open class FrameLayout(context: Context) : ViewGroup(context) {
+    private val matchParentChildren = mutableListOf<View>()
+
+    override fun generateDefaultLayoutParams(): LayoutParams =
+        LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        val horizontalPadding = paddingLeft + paddingRight
+        val verticalPadding = paddingTop + paddingBottom
+        val measureMatchParentChildren = MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
+            MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY
+        matchParentChildren.clear()
+        var maxWidth = 0
+        var maxHeight = 0
+        for (index in 0 until childCount) {
+            val child = checkNotNull(getChildAt(index))
+            val params = checkNotNull(child.layoutParams)
+            child.measure(
+                getChildMeasureSpec(widthMeasureSpec, horizontalPadding, params.width),
+                getChildMeasureSpec(heightMeasureSpec, verticalPadding, params.height),
+            )
+            maxWidth = maxOf(maxWidth, child.measuredWidth)
+            maxHeight = maxOf(maxHeight, child.measuredHeight)
+            if (measureMatchParentChildren &&
+                (params.width == LayoutParams.MATCH_PARENT || params.height == LayoutParams.MATCH_PARENT)) {
+                matchParentChildren += child
+            }
+        }
+        setMeasuredDimension(
+            View.resolveSize(maxOf(minimumWidth, maxWidth + horizontalPadding), widthMeasureSpec),
+            View.resolveSize(maxOf(minimumHeight, maxHeight + verticalPadding), heightMeasureSpec),
+        )
+        // android repeats measurement only when multiple children match the parent.
+        if (matchParentChildren.size > 1) {
+            for (child in matchParentChildren) {
+                val params = checkNotNull(child.layoutParams)
+                child.measure(
+                    if (params.width == LayoutParams.MATCH_PARENT)
+                        MeasureSpec.makeMeasureSpec((measuredWidth - horizontalPadding).coerceAtLeast(0), MeasureSpec.EXACTLY)
+                    else getChildMeasureSpec(widthMeasureSpec, horizontalPadding, params.width),
+                    if (params.height == LayoutParams.MATCH_PARENT)
+                        MeasureSpec.makeMeasureSpec((measuredHeight - verticalPadding).coerceAtLeast(0), MeasureSpec.EXACTLY)
+                    else getChildMeasureSpec(heightMeasureSpec, verticalPadding, params.height),
+                )
+            }
+        }
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        for (index in 0 until childCount) {
+            val child = checkNotNull(getChildAt(index))
+            child.layout(paddingLeft, paddingTop, paddingLeft + child.measuredWidth, paddingTop + child.measuredHeight)
+        }
+    }
+}