basalt-core 0.0.0-rc5 → 0.2.0

package/dist/src/overrides/processDecelerationRate.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * `decelerationRate`, for a desktop React Native platform.
+ *
+ * Not a shim, and the same failure as `<Button>`'s: React Native's own file is
+ * two `Platform.select({ios, android})` tables with no `default`, so on
+ * `linux`, `macos` or `windows` both of the prop's documented spellings --
+ * `'normal'` and `'fast'` -- resolve to `undefined`. `BaseScrollViewProps`
+ * then keeps its own default of 0.998, so `decelerationRate="fast"` scrolled
+ * at the normal rate and nothing said otherwise. Only a raw number worked.
+ *
+ * iOS's pair, because they are the pair this platform's own fling already
+ * uses: `core/ScrollMomentum.h` names 0.998 and 0.99 as what `'normal'` and
+ * `'fast'` mean, and a per-millisecond friction factor is the same model
+ * UIScrollView and every browser use. Android's 0.985 and 0.9 are a different
+ * curve's constants and would make a fling stop in a third of the distance.
+ *
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = processDecelerationRate;
+function processDecelerationRate(decelerationRate) {
+    if (decelerationRate === 'normal') {
+        return 0.998;
+    }
+    if (decelerationRate === 'fast') {
+        return 0.99;
+    }
+    return decelerationRate;
+}
+//# sourceMappingURL=processDecelerationRate.js.map

package/dist/src/overrides/processDecelerationRate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"processDecelerationRate.js","sourceRoot":"","sources":["../../../src/overrides/processDecelerationRate.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;AAEH,0CAUC;AAVD,SAAwB,uBAAuB,CAC7C,gBAA4C;IAE5C,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QAClC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,gBAAgB,KAAK,MAAM,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,gBAAgB,CAAC;AAC1B,CAAC"}

package/dist/src/useContextMenu.d.ts

@@ -63,20 +63,71 @@
  * @format
  */
 /**
- * One item in a context menu, as `native/core/MenuModel.h` reads it, plus the
- * handler this file calls.
+ * One item in a context menu: the four fields `entriesFrom` in
+ * `native/core/MenuModule.cpp` reads into a `MenuEntry`, plus the handler this
+ * file calls.
+ *
+ * A popup menu is a flat list on all three desktops, so there is no `submenu`
+ * and no `role` here -- nesting and the platform roles are what a menu *bar*
+ * is for, and `<Menu.Item>` is where they live.
  *
  * `onSelect` is the only field the native side does not see: the promise
  * carries the index back, and this calls the handler before settling it.
  */
 export type ContextMenuItem = {
     label?: string;
-    /** One of the platform roles; see native/core/MenuModel.h. */
-    role?: string;
-    /** "CmdOrCtrl+O", in Electron's spelling. Ignored for a role. */
-    accelerator?: string;
+    /**
+     * Drawn beside the label -- "Cmd+C", "Del". Decoration only: nothing here
+     * binds a key. Note the menu *bar* spells the same idea `accelerator`,
+     * because there it really does bind one.
+     */
+    shortcut?: string;
     enabled?: boolean;
     separator?: boolean;
+    /**
+     * One of the platform roles, in Electron's spelling: `about`, `quit`, `undo`,
+     * `redo`, `cut`, `copy`, `paste`, `delete`, `selectAll`, `minimize`, `zoom`,
+     * `close`, `togglefullscreen`. The platform performs it -- the Copy that
+     * actually copies the field the person was in -- and `onSelect` still runs, so
+     * an app can both get the behaviour and hear about it.
+     *
+     * **A role this desktop cannot perform is left out of the menu**, rather than
+     * shown doing nothing. It keeps its index though: what comes back is an index
+     * into the list you passed, so adding a role that one platform lacks does not
+     * renumber the items after it.
+     *
+     * The three do not agree. macOS has all thirteen; Linux and Windows have
+     * twelve, both missing `about`, neither having a platform about panel to ask
+     * for -- that window is an app's own to show, and an ordinary item with an
+     * `onSelect` is how to open it.
+     */
+    role?: string;
+    /**
+     * A tick or a radio mark beside the label.
+     *
+     * `checked` on its own means a checkbox, so the common case is one word. The
+     * kind is a separate field because it has to be: a GMenu item carries no
+     * checked attribute, and GTK picks a tick or a circle from the shape of the
+     * action behind it, which a boolean cannot express.
+     *
+     * `'radio'` is a drawing hint, not a capability. Windows draws a bullet and
+     * Linux a circle; macOS draws a tick, `NSMenu` having no radio item and a tick
+     * being what Apple's guidance prescribes for a chosen member of a group.
+     *
+     * A group is a run of adjacent `'radio'` items, ended by a separator or by any
+     * other kind of item. There is no group name to pass. Exclusivity is yours:
+     * the menu is built fresh each time it opens, so it draws the marks you give
+     * it and keeping one member checked is the caller's.
+     */
+    type?: 'checkbox' | 'radio';
+    checked?: boolean;
+    /**
+     * Nested items. The parent is not choosable: it opens its children.
+     *
+     * Both a `submenu` and a `role` on one item is a mistake, and the submenu
+     * wins. A parent whose children are all roles this desktop cannot perform is
+     * left out with them, an empty submenu being a dead end rather than an item.
+     */
     submenu?: ReadonlyArray<ContextMenuItem>;
     onSelect?: () => void;
 };

package/dist/src/useContextMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useContextMenu.d.ts","sourceRoot":"","sources":["../../src/useContextMenu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAKH;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACzC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAYF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,SAAsC,CAAC;AAE/D,iBAAe,IAAI,CACjB,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,EACrC,KAAK,CAAC,EAAE,gBAAgB,GAAG,IAAI,GAC9B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoBxB;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW;;;EAAqC,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C,wBAAgB,cAAc,IAAI,WAAW,CAK5C"}
+{"version":3,"file":"useContextMenu.d.ts","sourceRoot":"","sources":["../../src/useContextMenu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAKH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACzC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAYF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,SAAsC,CAAC;AAE/D,iBAAe,IAAI,CACjB,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,EACrC,KAAK,CAAC,EAAE,gBAAgB,GAAG,IAAI,GAC9B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoBxB;AAyCD;;;GAGG;AACH,eAAO,MAAM,WAAW;;;EAAqC,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C,wBAAgB,cAAc,IAAI,WAAW,CAK5C"}

package/dist/src/useContextMenu.js

@@ -92,9 +92,42 @@ async function show(items, where) {
     }
     // Called before the promise settles, so that an app which only wants
     // `onSelect` never has to await anything.
-    items[index]?.onSelect?.();
+    itemAt(items, index)?.onSelect?.();
     return index;
 }
+/**
+ * The item an index names, which is its position in a pre-order walk of the
+ * whole menu: an item, then its children, then the next item, counting
+ * separators and parents.
+ *
+ * For a flat list that is the position in the array, which is what this answered
+ * when a popup could only be flat, so an index means what it has always meant.
+ * The native side numbers its items the same way; see `walkMenuEntries` in
+ * core/PlatformServices.h, which is the other half of this contract.
+ *
+ * An item the platform left out still counts, which is what lets both sides
+ * agree without this knowing which roles the platform has: the native side
+ * numbers every entry it was given and draws only the ones it can. See
+ * `menuEntryShown` beside it.
+ */
+function itemAt(items, index) {
+    let next = 0;
+    const walk = (level) => {
+        for (const item of level) {
+            if (next++ === index) {
+                return item;
+            }
+            if (item.submenu != null && item.submenu.length > 0) {
+                const found = walk(item.submenu);
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    };
+    return walk(items);
+}
 /**
  * The imperative half, usable outside a component -- the same arrangement
  * `useDialog()` and `windowControl` have.

package/dist/src/useContextMenu.js.map

@@ -1 +1 @@
-{"version":3,"file":"useContextMenu.js","sourceRoot":"","sources":["../../src/useContextMenu.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;;;AAuFH,wCAKC;AAzFD,+CAAiD;AAyCjD,MAAM,UAAU,GAAG,kCAAmB,CAAC,GAAG,CAAmB,YAAY,CAAC,CAAC;AAE3E;;;;;GAKG;AACU,QAAA,WAAW,GAAG,UAAU,EAAE,eAAe,IAAI,IAAI,CAAC;AAE/D,KAAK,UAAU,IAAI,CACjB,KAAqC,EACrC,KAA+B;IAE/B,IAAI,CAAC,mBAAW,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,4EAA4E;IAC5E,6EAA6E;IAC7E,2CAA2C;IAC3C,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC;IACzC,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC;IAEzC,6EAA6E;IAC7E,8EAA8E;IAC9E,MAAM,KAAK,GAAG,MAAM,UAAW,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7D,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,qEAAqE;IACrE,0CAA0C;IAC1C,KAAK,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC;IAC3B,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACU,QAAA,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAC,IAAI,EAAE,WAAW,EAAX,mBAAW,EAAC,CAAC,CAAC;AAI9D,SAAgB,cAAc;IAC5B,0EAA0E;IAC1E,8EAA8E;IAC9E,2BAA2B;IAC3B,OAAO,mBAAW,CAAC;AACrB,CAAC"}
+{"version":3,"file":"useContextMenu.js","sourceRoot":"","sources":["../../src/useContextMenu.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;;;AAiLH,wCAKC;AAnLD,+CAAiD;AA4FjD,MAAM,UAAU,GAAG,kCAAmB,CAAC,GAAG,CAAmB,YAAY,CAAC,CAAC;AAE3E;;;;;GAKG;AACU,QAAA,WAAW,GAAG,UAAU,EAAE,eAAe,IAAI,IAAI,CAAC;AAE/D,KAAK,UAAU,IAAI,CACjB,KAAqC,EACrC,KAA+B;IAE/B,IAAI,CAAC,mBAAW,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,4EAA4E;IAC5E,6EAA6E;IAC7E,2CAA2C;IAC3C,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC;IACzC,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC;IAEzC,6EAA6E;IAC7E,8EAA8E;IAC9E,MAAM,KAAK,GAAG,MAAM,UAAW,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7D,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,qEAAqE;IACrE,0CAA0C;IAC1C,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC;IACnC,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,MAAM,CACb,KAAqC,EACrC,KAAa;IAEb,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,MAAM,IAAI,GAAG,CACX,KAAqC,EACR,EAAE;QAC/B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,IAAI,EAAE,KAAK,KAAK,EAAE,CAAC;gBACrB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACjC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;oBAClB,OAAO,KAAK,CAAC;gBACf,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IACF,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;AACrB,CAAC;AAED;;;GAGG;AACU,QAAA,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,EAAC,IAAI,EAAE,WAAW,EAAX,mBAAW,EAAC,CAAC,CAAC;AAI9D,SAAgB,cAAc;IAC5B,0EAA0E;IAC1E,8EAA8E;IAC9E,2BAA2B;IAC3B,OAAO,mBAAW,CAAC;AACrB,CAAC"}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/dragsource.tsx","../src/droptarget.tsx","../src/keyhandler.tsx","../src/menu.tsx","../src/titlebar.tsx","../src/window.tsx","../src/closerequest.ts","../src/globals.d.ts","../src/index.ts","../src/quitrequest.ts","../src/resourcepath.ts","../src/responsebody.ts","../src/responseheaders.ts","../src/titlebarstate.ts","../src/usecontextmenu.ts","../src/usedialog.ts","../src/usedisplays.ts","../src/usehandledkeys.ts","../src/usewindow.ts","../src/overrides/alert.ts","../src/overrides/baseviewconfig.ts","../src/overrides/platform.d.ts","../src/overrides/platform.linux.ts","../src/overrides/platform.macos.ts","../src/overrides/platform.windows.ts","../src/overrides/reactdevtoolssettingsmanager.ts","../src/overrides/refreshcontrol.tsx","../src/overrides/scrollview.tsx","../src/overrides/share.ts","../src/overrides/textinput.tsx","../src/overrides/view.tsx","../src/overrides/createplatform.ts","../src/overrides/setupdevelopertools.ts","../src/overrides/setupxhr.ts","../src/overrides/upstream.d.ts","../cli/basalt.ts","../cli/bundle-cli.ts","../cli/bundlewithassets.ts","../cli/desktop.ts","../cli/doctor.ts","../cli/init.ts","../cli/metro.ts","../cli/packageapp.ts","../cli/steps.ts","../react-native.config.js"],"version":"6.0.3"}
+{"root":["../src/DragSource.tsx","../src/DropTarget.tsx","../src/KeyHandler.tsx","../src/Menu.tsx","../src/TitleBar.tsx","../src/Window.tsx","../src/closeRequest.ts","../src/globals.d.ts","../src/index.ts","../src/quitRequest.ts","../src/resourcePath.ts","../src/responseBody.ts","../src/responseHeaders.ts","../src/titleBarState.ts","../src/useContextMenu.ts","../src/useDialog.ts","../src/useDisplays.ts","../src/useHandledKeys.ts","../src/useWindow.ts","../src/overrides/Alert.ts","../src/overrides/BaseViewConfig.ts","../src/overrides/Button.tsx","../src/overrides/Platform.d.ts","../src/overrides/Platform.linux.ts","../src/overrides/Platform.macos.ts","../src/overrides/Platform.windows.ts","../src/overrides/ReactDevToolsSettingsManager.ts","../src/overrides/RefreshControl.tsx","../src/overrides/ScrollView.tsx","../src/overrides/Settings.ts","../src/overrides/Share.ts","../src/overrides/TextInput.tsx","../src/overrides/View.tsx","../src/overrides/createPlatform.ts","../src/overrides/processDecelerationRate.ts","../src/overrides/setUpDeveloperTools.ts","../src/overrides/setUpXHR.ts","../src/overrides/upstream.d.ts","../cli/basalt.ts","../cli/bundle-cli.ts","../cli/bundleWithAssets.ts","../cli/desktop.ts","../cli/doctor.ts","../cli/init.ts","../cli/metro.ts","../cli/packageApp.ts","../cli/steps.ts","../react-native.config.js"],"version":"6.0.3"}

package/native/CMakeLists.txt

@@ -38,6 +38,14 @@ get_filename_component(BASALT_THIRD_PARTY "${BASALT_THIRD_PARTY}" ABSOLUTE)
 # it alongside its own tests and brings its own `main`; see docs/TESTING.md.
 set(BASALT_TEST_HARNESS ${CMAKE_CURRENT_SOURCE_DIR}/tests/TestHarness.cpp
     CACHE INTERNAL "the toolkit-free test runner")
+# What the harness calls and cannot define: a crashing test prints a stack
+# rather than a silent non-zero exit. It lives in basalt_core, which a suite
+# linking that target gets for free -- and the Windows view layer builds with
+# no React Native and therefore no basalt_core, so that build has to compile
+# this one file itself. Named here, beside the harness that needs it, rather
+# than spelled as a path in the package that happens to hit the problem.
+set(BASALT_CRASH_HANDLER ${CMAKE_CURRENT_SOURCE_DIR}/core/CrashHandler.cpp
+    CACHE INTERNAL "the crash handler the test harness installs")
 set(BASALT_TEST_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/tests
     CACHE INTERNAL "where TestHarness.h lives")
 
@@ -52,13 +60,35 @@ set(BASALT_CORE_TESTS
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_app_paths.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_animation.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_backface.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_gradients.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_label_registry.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_live_regions.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_filters.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_blend_modes.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_legacy_shadow.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_shadow_shape.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_background_layers.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_shadows.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_font_scaling.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_decorations.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_colors.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_font_variants.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_checking.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_drag_and_drop.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_quit_file.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_menu_entries.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_settle.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_key_events.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_js_runtime_access.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_image_cache.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_image_animation.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_image_progress.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_device_metrics.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_app_state.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_system_locale.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_font_fitting.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_bounds.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_visible_position.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_indicator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scroll_snap.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_window_close.cpp
@@ -71,6 +101,10 @@ set(BASALT_CORE_TESTS
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_hover.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_momentum.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_share.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_settings_store.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_action_sheet.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_alignment.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_text_selection.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_sourcecode.cpp
     CACHE INTERNAL "core's own tests")
 
@@ -159,6 +193,22 @@ if(DEFINED RN_DIR)
   get_property(basalt_package_installers GLOBAL PROPERTY BASALT_PACKAGE_EXPO_INSTALLERS)
   get_property(basalt_package_core_sources GLOBAL PROPERTY BASALT_PACKAGE_CORE_SOURCES)
   get_property(basalt_package_includes GLOBAL PROPERTY BASALT_PACKAGE_INCLUDES)
+  # And the ones that are somebody else's headers, which cannot be held to
+  # this project's warnings: Skia's trip `-Wpedantic` on a variadic macro, as
+  # React Native's own trip several, which is why those are `SYSTEM` too. A
+  # package says which of its include directories are its own and which are a
+  # dependency's.
+  get_property(basalt_package_system_includes GLOBAL PROPERTY BASALT_PACKAGE_SYSTEM_INCLUDES)
+  # And what a package wants *said* about itself, as preprocessor definitions.
+  #
+  # The hosts already have `BASALT_HAS_SKIA` and `BASALT_HAS_WORKLETS`, both set
+  # by a cmake/ file in this package for a dependency this package knows about.
+  # A capability package in somebody else's node_modules cannot reach either, and
+  # the first one that needed to is basalt-skia: whether the installed Skia is
+  # Graphite decides which of two canvases the AppKit mounting manager calls, and
+  # which surface the platform context makes. PUBLIC, so it reaches the host
+  # packages and their tests and not only core's own sources.
+  get_property(basalt_package_definitions GLOBAL PROPERTY BASALT_PACKAGE_DEFINITIONS)
 
   # A semicolon by character code: CMake treats `;` as a list separator, and
   # escaping it as `\;` survives into the generated file rather than becoming
@@ -203,7 +253,12 @@ if(DEFINED RN_DIR)
     core/ImageCache.cpp
     core/ScrollBounds.cpp
     core/ScrollIndicator.cpp
+    core/AppStateHost.cpp
+    core/SystemLocale.cpp
+    core/DeviceMetrics.cpp
     core/ScrollSnap.cpp
+    # Keeping the content still while items are inserted above it.
+    core/ScrollVisiblePosition.cpp
     # `Appearance`, and the portable half of light-vs-dark.
     core/AppearanceModule.cpp
     # Blob, File and FileReader -- portable in full.
@@ -212,6 +267,8 @@ if(DEFINED RN_DIR)
     core/ColorScheme.cpp
     # Clipboard, Vibration, Alert, Linking, I18nManager, AccessibilityInfo --
     # the core modules ReactCxxPlatform does not provide.
+    # `ActionSheetIOS`, which is a popup menu here; see the header.
+    core/ActionSheet.cpp
     core/CoreModules.cpp
     # <ActivityIndicator>, <Switch>, <RefreshControl> and <Modal>: the props
     # three view layers have to read identically, plus the two shadow-node
@@ -229,6 +286,8 @@ if(DEFINED RN_DIR)
     core/DebuggingOverlay.cpp
     core/DevBundle.cpp
     core/ExpoImageComponent.cpp
+    core/SafeAreaComponent.cpp
+    core/ScreensComponent.cpp
     core/GestureHandlerModule.cpp
     core/Gestures.cpp
     # Hover: the pointer-event path React Native only has on Android.
@@ -251,14 +310,23 @@ if(DEFINED RN_DIR)
     core/ScrollMomentum.cpp
     # A share sheet for the desktops that have none; see the header.
     core/ShareFallback.cpp
+    # `Settings`, which is a file here rather than NSUserDefaults; see the header.
+    core/SettingsStore.cpp
+    # Which way a paragraph runs when the app did not say; see the header.
+    core/TextDirection.cpp
+    # What a press and a drag mean inside selectable text; see the header.
+    core/TextSelection.cpp
     core/SourceCodeModule.cpp
     # Answering a modal dialog without showing one; see the header.
     core/TestDialog.cpp
+    # What the host says when it dies, which was nothing; see the header.
+    core/CrashHandler.cpp
     # Quitting gracefully when the harness says so, rather than on a budget
     # fixed before launch; see the header.
     core/TestQuitFile.cpp
     # What a <Canvas> from @shopify/react-native-skia mounts; see the header.
     core/SkiaPictureViewComponent.cpp
+    core/SkiaViewComponent.cpp
     # globalThis.__turboModuleProxy, which a bridgeless runtime does not get; see
     # the header.
     core/TurboModuleProxy.cpp
@@ -303,7 +371,13 @@ if(DEFINED RN_DIR)
   target_compile_definitions(basalt_core PUBLIC
     BASALT_REACT_NATIVE_VERSION="${RN_VERSION}"
     BASALT_RN_MINOR=${RN_MINOR})
+  if(basalt_package_definitions)
+    target_compile_definitions(basalt_core PUBLIC ${basalt_package_definitions})
+  endif()
   target_include_directories(basalt_core PUBLIC core ${basalt_package_includes})
+  if(basalt_package_system_includes)
+    target_include_directories(basalt_core SYSTEM PUBLIC ${basalt_package_system_includes})
+  endif()
   target_include_directories(basalt_core SYSTEM PUBLIC
     ${RN_DIR}/ReactCommon
     ${RN_DIR}/ReactCommon/jsi
@@ -316,7 +390,17 @@ if(DEFINED RN_DIR)
     # "iosswitch" and which are ordinary portable C++ apart from the one
     # measurement core/DesktopControls.cpp supplies. Android's needs fbjni;
     # this one needs nothing.
-    ${RN_DIR}/ReactCommon/react/renderer/components/switch/iosswitch)
+    ${RN_DIR}/ReactCommon/react/renderer/components/switch/iosswitch
+    # Hermes' public headers, which core already links and until now only its
+    # own directory could include. `include_directories()` in ThirdParty.cmake
+    # is directory-scoped, so a test in a *host* package linking core could
+    # call into Hermes and not include <hermes/hermes.h> -- which is what a
+    # test that wants a real jsi::Runtime needs, and the first one that wanted
+    # one is basalt-skia's. The same two directories ThirdParty.cmake names,
+    # for the same reason: RN's jsi is used rather than Hermes' vendored copy,
+    # so API/ and public/ only.
+    ${HERMES_DIR}/API
+    ${HERMES_DIR}/public)
   # libcurl, because core/HttpClient.cpp is here. It used to be named only on
   # basalt_gtk_mounting, which worked for exactly as long as the GTK host was the only
   # thing linking core: the archive member goes unreferenced until something

package/native/cmake/Skia.cmake

@@ -65,9 +65,35 @@ endif()
 
 if(NOT EXISTS ${SKIA_CPP_DIR}/rnskia/RNSkManager.cpp)
   message(FATAL_ERROR
-          "no @shopify/react-native-skia C++ at ${SKIA_CPP_DIR}.\n"
-          "BASALT_SKIA should name an installed @shopify/react-native-skia, "
-          "the one in the app's node_modules.")
+          "no React Native Skia C++ at ${SKIA_CPP_DIR}.\n"
+          "BASALT_SKIA should name an installed react-native-skia or "
+          "@shopify/react-native-skia, the one in the app's node_modules.")
+endif()
+
+file(READ ${SKIA_DIR}/package.json SKIA_PACKAGE_JSON)
+string(JSON SKIA_VERSION GET "${SKIA_PACKAGE_JSON}" version)
+
+# 3.x is a different renderer, not a newer one.
+#
+# It replaced Ganesh with Skia Graphite over Dawn, and this file is the Ganesh
+# half: six of the seven Apple sources it borrows below do not exist in 3.x, and
+# their replacement -- RNSkWindowSurface, which is portable C++ rather than
+# Objective-C++ -- configures a CAMetalLayer or an ANativeWindow as a Dawn
+# surface and nothing else, so neither GTK nor Win32 can use it as shipped
+# either. backlog/compatibility.md records what each of the three would take.
+#
+# Said here as well as in the CLI because BASALT_SKIA can be set by hand, and
+# the failure it saves is a bad one: `MetalContext.mm does not exist`, from a
+# source list, naming a file nobody deleted. A version is the actual reason and
+# this is the first place that knows it.
+string(REGEX MATCH "^[0-9]+" SKIA_MAJOR "${SKIA_VERSION}")
+if(SKIA_MAJOR AND SKIA_MAJOR GREATER_EQUAL 3)
+  message(FATAL_ERROR
+          "Skia ${SKIA_VERSION} at ${SKIA_DIR} is Graphite over Dawn, and this "
+          "platform's half is Ganesh.\n"
+          "Install the 2.x line -- `react-native-skia@release-2.x`, or "
+          "`@shopify/react-native-skia` -- or configure without BASALT_SKIA, "
+          "until basalt-skia carries the Graphite half.")
 endif()
 
 # The binaries are not in the package's `files`: they are downloaded, by the
@@ -96,9 +122,6 @@ if(NOT APPLE AND NOT WIN32 AND NOT EXISTS ${SKIA_LIBS_DIR}/libskia.a)
           "its libs/linux/x86_64 here.")
 endif()
 
-file(READ ${SKIA_DIR}/package.json SKIA_PACKAGE_JSON)
-string(JSON SKIA_VERSION GET "${SKIA_PACKAGE_JSON}" version)
-
 # Every prebuilt archive the package imports on Apple, each a universal slice.
 # Named rather than globbed: a missing one is a link error in somebody else's
 # symbols, and a list says which we expected.

package/native/core/ActionSheet.cpp

@@ -0,0 +1,75 @@
+#include "ActionSheet.h"
+
+#include <algorithm>
+
+namespace basalt {
+
+namespace {
+
+MenuEntry disabledEntry(const std::string &label) {
+  // Assigned rather than a designated initializer, for the reason
+  // MenuEntry::separator() gives: a partial initializer list is an error under
+  // the -Werror the GTK build turns on.
+  MenuEntry entry;
+  entry.label = label;
+  entry.enabled = false;
+  return entry;
+}
+
+bool contains(const std::vector<int> &values, int value) {
+  return std::find(values.begin(), values.end(), value) != values.end();
+}
+
+} // namespace
+
+ActionSheetMenu actionSheetMenu(const ActionSheetRequest &request) {
+  ActionSheetMenu built;
+  built.menu.x = request.x;
+  built.menu.y = request.y;
+
+  if (!request.title.empty()) {
+    built.menu.entries.push_back(disabledEntry(request.title));
+  }
+  if (!request.message.empty()) {
+    built.menu.entries.push_back(disabledEntry(request.message));
+  }
+  if (!built.menu.entries.empty()) {
+    built.menu.entries.push_back(MenuEntry::separator());
+  }
+  built.offset = static_cast<int>(built.menu.entries.size());
+
+  for (size_t index = 0; index < request.options.size(); ++index) {
+    MenuEntry entry;
+    entry.label = request.options[index];
+    entry.enabled = !contains(request.disabledIndices, static_cast<int>(index));
+    built.menu.entries.push_back(entry);
+  }
+
+  return built;
+}
+
+std::optional<int> actionSheetChoice(const ActionSheetRequest &request,
+                                     const ActionSheetMenu &menu,
+                                     int chosen) {
+  const int count = static_cast<int>(request.options.size());
+
+  if (chosen < 0) {
+    // Dismissed. The cancel choice when the app named one, and otherwise
+    // nothing at all; see the header.
+    if (request.cancelIndex >= 0 && request.cancelIndex < count) {
+      return request.cancelIndex;
+    }
+    return std::nullopt;
+  }
+
+  const int option = chosen - menu.offset;
+  if (option < 0 || option >= count) {
+    // A header, or an index no entry of this menu has. Not reported: the app's
+    // callback takes an index into the array it passed, and there is nothing
+    // here to pass it.
+    return std::nullopt;
+  }
+  return option;
+}
+
+} // namespace basalt

package/native/core/ActionSheet.h

@@ -0,0 +1,90 @@
+// `ActionSheetIOS`, which on a desktop is a popup menu.
+//
+// `ActionSheetManager` is a `get` lookup, so its absence was not a crash: the
+// module came back null and `ActionSheetIOS.showActionSheetWithOptions` died on
+// `invariant(RCTActionSheetManager, "ActionSheetManager doesn't exist")` at the
+// first call. Unlike `Settings`, `Share` and `Alert`, there is no JavaScript to
+// replace -- `ActionSheetIOS.js` has no `Platform.OS` branch at all and calls
+// the module directly, which is why this is a module and nothing else. Worth
+// knowing that the two shapes exist: an iOS-named API is not automatically one
+// whose JavaScript refuses to run off iOS.
+//
+// ## A menu rather than a dialog
+//
+// An action sheet is a list of choices, one of which usually cancels, shown
+// because of something the person just did. On a desktop that is a popup menu,
+// and the alternative -- `presentAlert`, which this project already has -- loses
+// more than it gains: a dialog can show the sheet's `title` and `message`, and
+// it cannot show eight choices without looking like a mistake, cannot grey one
+// out, and cannot be dismissed with Escape the way a menu can.
+//
+// So it is `presentMenu`, and the title and message go in as disabled entries
+// at the top. That is a real desktop pattern and it moves the options down the
+// list, which is why `offset` below exists: JavaScript numbers the array it
+// passed, and a menu index counts every entry.
+//
+// ## What a desktop cannot do with it
+//
+// `destructiveButtonIndex` is accepted and ignored. None of the three can style
+// one item of a popup menu as dangerous: GTK's `destructive-action` is a button
+// class, `NSMenuItem` has no such style, and a Win32 menu item has no colour of
+// its own. `tintColor`, `cancelButtonTintColor`, `disabledButtonTintColor` and
+// `userInterfaceStyle` are iOS's own and are likewise ignored rather than
+// refused, so code written for iOS runs unchanged. `disabledButtonIndices` is
+// the one that *does* work, because a menu entry can be greyed.
+
+#pragma once
+
+#include "PlatformServices.h"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace basalt {
+
+// What the app asked for, read off the options object once.
+struct ActionSheetRequest {
+  std::string title;
+  std::string message;
+  std::vector<std::string> options;
+  // Indices into `options`, as `disabledButtonIndices` names them.
+  std::vector<int> disabledIndices;
+  // `cancelButtonIndex`, or -1 when the app named none. It is what a dismissal
+  // reports; see actionSheetChoice.
+  int cancelIndex{-1};
+  // Where the menu goes, in the window's coordinates. Negative means "wherever
+  // the pointer is", which is what MenuRequest means by it and what a sheet with
+  // no `anchor` wants.
+  double x{-1.0};
+  double y{-1.0};
+};
+
+// The popup menu an action sheet becomes, and how to read an answer back out.
+struct ActionSheetMenu {
+  MenuRequest menu;
+  // How many entries the title, the message and their separator took, which is
+  // the difference between a menu index and the option index an app knows.
+  int offset{0};
+};
+
+ActionSheetMenu actionSheetMenu(const ActionSheetRequest &request);
+
+// Which option to report for the menu index `chosen`, or nothing when the app's
+// callback should not be called at all.
+//
+// Nothing, rather than -1, because that is iOS's behaviour and it is load
+// bearing: `UIAlertController` invokes the callback from a button's handler, so
+// a sheet that goes away without a button being pressed calls nothing, and an
+// app that would otherwise act on "index -1" never has to.
+//
+// A dismissal is the one case where this platform answers something iOS does
+// not. Escape closing a menu is far more ordinary than an iPad popover being
+// tapped away, and an app that offered a cancel choice has already said what to
+// do with it -- so a dismissal reports `cancelIndex` when there is one, and
+// nothing when there is not.
+std::optional<int> actionSheetChoice(const ActionSheetRequest &request,
+                                    const ActionSheetMenu &menu,
+                                    int chosen);
+
+} // namespace basalt

package/native/core/AppStateHost.cpp

@@ -0,0 +1,76 @@
+#include "AppStateHost.h"
+
+#include <atomic>
+#include <mutex>
+
+namespace basalt {
+
+namespace {
+
+std::mutex &lock() {
+  static std::mutex value;
+  return value;
+}
+
+std::atomic<AppStateKind> &state() {
+  // Active, not unknown: a host that never reports has still put a window on
+  // the screen, and `AppState.currentState` is read before any event can
+  // arrive. React Native has an `unknown` for a platform that cannot tell, and
+  // all three of these can.
+  static std::atomic<AppStateKind> value{AppStateKind::Active};
+  return value;
+}
+
+std::function<void(AppStateKind)> &listener() {
+  static std::function<void(AppStateKind)> value;
+  return value;
+}
+
+} // namespace
+
+const char *appStateName(AppStateKind state) {
+  switch (state) {
+    case AppStateKind::Active:
+      return "active";
+    case AppStateKind::Inactive:
+      return "inactive";
+    case AppStateKind::Background:
+      return "background";
+  }
+  return "active";
+}
+
+AppStateKind appStateFor(bool focused, bool visible) {
+  if (!visible) {
+    return AppStateKind::Background;
+  }
+  return focused ? AppStateKind::Active : AppStateKind::Inactive;
+}
+
+void notifyAppState(AppStateKind next) {
+  std::function<void(AppStateKind)> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    if (state().load(std::memory_order_relaxed) == next) {
+      return;
+    }
+    state().store(next, std::memory_order_relaxed);
+    toCall = listener();
+  }
+  // Outside the lock: it emits into the JavaScript runtime, and holding a lock
+  // across that is how a deadlock is built.
+  if (toCall) {
+    toCall(next);
+  }
+}
+
+AppStateKind currentAppState() {
+  return state().load(std::memory_order_relaxed);
+}
+
+void setAppStateListener(std::function<void(AppStateKind)> next) {
+  const std::lock_guard<std::mutex> guard(lock());
+  listener() = std::move(next);
+}
+
+} // namespace basalt