bare-ui-kit 0.2.0 → 0.3.0

package/lib/pasteboard.h

@@ -0,0 +1,123 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_pasteboard_general_pasteboard(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, NULL, NULL, NULL, (void **) &state);
+  assert(err == 0);
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIPasteboard generalPasteboard]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_pasteboard_string(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1 || argc == 2);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result = NULL;
+
+  @autoreleasepool {
+    UIPasteboard *pasteboard = (__bridge UIPasteboard *) handle;
+
+    if (argc == 1) {
+      result = bare_ui_kit__from_string(env, pasteboard.string);
+    } else {
+      pasteboard.string = bare_ui_kit__to_string(env, argv[1]);
+    }
+  }
+
+  return result;
+}
+
+#define V(name, property) \
+  static js_value_t * \
+  name(js_env_t *env, js_callback_info_t *info) { \
+    int err; \
+\
+    size_t argc = 1; \
+    js_value_t *argv[1]; \
+\
+    bare_ui_kit_state_t *state; \
+    err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state); \
+    assert(err == 0); \
+\
+    assert(argc == 1); \
+\
+    void *handle; \
+    if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL; \
+\
+    js_value_t *result; \
+\
+    @autoreleasepool { \
+      UIPasteboard *pasteboard = (__bridge UIPasteboard *) handle; \
+\
+      err = js_get_boolean(env, pasteboard.property, &result); \
+      assert(err == 0); \
+    } \
+\
+    return result; \
+  }
+
+V(bare_ui_kit_pasteboard_has_strings, hasStrings)
+V(bare_ui_kit_pasteboard_has_urls, hasURLs)
+V(bare_ui_kit_pasteboard_has_images, hasImages)
+V(bare_ui_kit_pasteboard_has_colors, hasColors)
+#undef V
+
+#define V(name, property) \
+  static js_value_t * \
+  name(js_env_t *env, js_callback_info_t *info) { \
+    int err; \
+\
+    size_t argc = 1; \
+    js_value_t *argv[1]; \
+\
+    bare_ui_kit_state_t *state; \
+    err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state); \
+    assert(err == 0); \
+\
+    assert(argc == 1); \
+\
+    void *handle; \
+    if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL; \
+\
+    js_value_t *result; \
+\
+    @autoreleasepool { \
+      UIPasteboard *pasteboard = (__bridge UIPasteboard *) handle; \
+\
+      err = js_create_int64(env, pasteboard.property, &result); \
+      assert(err == 0); \
+    } \
+\
+    return result; \
+  }
+
+V(bare_ui_kit_pasteboard_number_of_items, numberOfItems)
+V(bare_ui_kit_pasteboard_change_count, changeCount)
+#undef V

package/lib/pasteboard.js

@@ -0,0 +1,63 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const wrap = require('./wrap')
+
+module.exports = exports = class UIKitPasteboard {
+  constructor(opts = {}) {
+    const { tag = null } = opts
+
+    this._tag = tag
+
+    this._token = binding.claim(this._tag, this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  static get generalPasteboard() {
+    return wrap(UIKitPasteboard, binding.pasteboardGeneralPasteboard())
+  }
+
+  get string() {
+    return binding.pasteboardString(this._tag)
+  }
+
+  set string(string) {
+    binding.pasteboardString(this._tag, string)
+  }
+
+  get hasStrings() {
+    return binding.pasteboardHasStrings(this._tag)
+  }
+
+  get hasURLs() {
+    return binding.pasteboardHasUrls(this._tag)
+  }
+
+  get hasImages() {
+    return binding.pasteboardHasImages(this._tag)
+  }
+
+  get hasColors() {
+    return binding.pasteboardHasColors(this._tag)
+  }
+
+  get numberOfItems() {
+    return binding.pasteboardNumberOfItems(this._tag)
+  }
+
+  get changeCount() {
+    return binding.pasteboardChangeCount(this._tag)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitPasteboard }
+    }
+  }
+}

package/lib/retain.js

@@ -0,0 +1,12 @@
+const wrap = require('./wrap')
+
+// Read the property every time, so the answer is right even when it was changed
+// natively, and keep the result, because the reference from a native object to
+// its wrapper is weak.
+module.exports = exports = function retain(holder, key, Class, tag) {
+  const value = wrap(Class, tag)
+
+  holder[key] = value
+
+  return value
+}

package/lib/runtime.m

@@ -1,5 +1,6 @@
 #import <assert.h>
 #import <bare.h>
+#import <stdbool.h>
 #import <js.h>
 #import <path.h>
 #import <rlimit.h>
@@ -20,6 +21,10 @@ static bare_t *bare;
 
 static dispatch_source_t bare__poll;
 static dispatch_source_t bare__timer;
+static CFRunLoopObserverRef bare__observer;
+
+static bool bare__exited;
+static bool bare__running;
 
 static void
 bare__on_shutdown(uv_async_t *handle) {
@@ -59,9 +64,17 @@ static void
 bare__run(void) {
   int err;
 
+  if (bare__running) return;
+
+  bare__running = true;
+
   err = bare_run(bare, UV_RUN_NOWAIT);
   assert(err >= 0);
 
+  bare__running = false;
+
+  if (bare__exited) return;
+
   int timeout = uv_backend_timeout(bare__loop);
 
   if (timeout == 0) {
@@ -69,7 +82,12 @@ bare__run(void) {
       bare__run();
     });
   } else if (timeout < 0) {
-    dispatch_source_cancel(bare__timer);
+    dispatch_source_set_timer(
+      bare__timer,
+      DISPATCH_TIME_FOREVER,
+      DISPATCH_TIME_FOREVER,
+      0
+    );
   } else {
     uint64_t nanoseconds = (uint64_t) timeout * NSEC_PER_MSEC;
 
@@ -125,6 +143,20 @@ bare__launch(void) {
   dispatch_resume(bare__poll);
   dispatch_resume(bare__timer);
 
+  bare__observer = CFRunLoopObserverCreateWithHandler(
+    NULL,
+    kCFRunLoopBeforeWaiting,
+    true,
+    0,
+    ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
+      if (bare__exited) return;
+
+      bare__run();
+    }
+  );
+
+  CFRunLoopAddObserver(CFRunLoopGetMain(), bare__observer, kCFRunLoopCommonModes);
+
   bare__run();
 }
 
@@ -132,17 +164,23 @@ static void
 bare__terminate(void) {
   int err;
 
+  CFRunLoopRemoveObserver(CFRunLoopGetMain(), bare__observer, kCFRunLoopCommonModes);
+
+  CFRelease(bare__observer);
+
   dispatch_source_cancel(bare__poll);
   dispatch_source_cancel(bare__timer);
 
   err = uv_async_send(&bare__shutdown);
   assert(err == 0);
 
-  err = bare_terminate(bare);
-  assert(err == 0);
+  if (!bare__exited) {
+    err = bare_terminate(bare);
+    assert(err == 0);
 
-  err = bare_run(bare, UV_RUN_DEFAULT);
-  assert(err == 0);
+    err = bare_run(bare, UV_RUN_DEFAULT);
+    assert(err == 0);
+  }
 
   int exit_code;
   err = bare_teardown(bare, UV_RUN_DEFAULT, &exit_code);
@@ -159,6 +197,17 @@ bare__terminate(void) {
   if (exit_code != 0) _exit(exit_code);
 }
 
+static void
+bare__on_exit(bare_t *bare, void *data) {
+  bare__exited = true;
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    bare__terminate();
+
+    exit(0);
+  });
+}
+
 static void
 bare__background(void) {
   int err;
@@ -173,32 +222,57 @@ bare__foreground(void) {
   assert(err == 0);
 }
 
-@interface BareApp : UIApplication <UIApplicationDelegate>
+// From iOS 26 an app that does not adopt the scene lifecycle traps on launch,
+// so the scene is the entry point. Its window only exists once it connects, so
+// the bundle is loaded here.
+@interface BareSceneDelegate : NSObject <UIWindowSceneDelegate>
 
 @end
 
-@implementation BareApp
+@implementation BareSceneDelegate
 
-- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
-  bare__launch();
+- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session options:(UISceneConnectionOptions *)options {
+  static bool launched = false;
 
-  return YES;
-}
+  if (launched) return;
 
-- (void)applicationWillTerminate:(UIApplication *)application {
-  bare__terminate();
+  launched = true;
+
+  bare__launch();
 }
 
-- (void)applicationDidEnterBackground:(UIApplication *)application {
+- (void)sceneDidEnterBackground:(UIScene *)scene {
   bare__background();
 }
 
-- (void)applicationWillEnterForeground:(UIApplication *)application {
+- (void)sceneWillEnterForeground:(UIScene *)scene {
   bare__foreground();
 }
 
 @end
 
+@interface BareApp : UIApplication <UIApplicationDelegate>
+
+@end
+
+@implementation BareApp
+
+- (UISceneConfiguration *)application:(UIApplication *)application configurationForConnectingSceneSession:(UISceneSession *)session options:(UISceneConnectionOptions *)options {
+  UISceneConfiguration *configuration = [UISceneConfiguration
+    configurationWithName:@"Default"
+             sessionRole:session.role];
+
+  configuration.delegateClass = BareSceneDelegate.class;
+
+  return configuration;
+}
+
+- (void)applicationWillTerminate:(UIApplication *)application {
+  bare__terminate();
+}
+
+@end
+
 int
 main(int argc, char *argv[]) {
   int err;
@@ -271,6 +345,9 @@ main(int argc, char *argv[]) {
   err = bare_setup(bare__loop, bare__platform, NULL, argc, (const char **) argv, NULL, &bare);
   assert(err == 0);
 
+  err = bare_on_exit(bare, bare__on_exit, NULL);
+  assert(err == 0);
+
   @autoreleasepool {
     return UIApplicationMain(argc, argv, @"BareApp", @"BareApp");
   }

package/lib/scene.d.ts

@@ -0,0 +1,30 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitScreen = require('./screen')
+
+/** A scene the app shows its windows in, as a `UIWindowScene`. */
+interface UIKitScene {
+  readonly screen: UIKitScreen | null
+
+  /** Whether the scene is in the foreground, as an `ACTIVATION_STATE` constant. */
+  readonly activationState: number
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitScene {
+  protected constructor()
+
+  /** The scenes that are connected. Put a window in one to show it. */
+  static readonly connected: UIKitScene[]
+
+  static readonly ACTIVATION_STATE: {
+    readonly UNATTACHED: number
+    readonly FOREGROUND_ACTIVE: number
+    readonly FOREGROUND_INACTIVE: number
+    readonly BACKGROUND: number
+  }
+}
+
+export = UIKitScene

package/lib/scene.h

@@ -0,0 +1,87 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_scene_connected(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, NULL, NULL, NULL, (void **) &state);
+  assert(err == 0);
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    NSMutableArray<UIWindowScene *> *scenes = [NSMutableArray array];
+
+    for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
+      if ([scene isKindOfClass:UIWindowScene.class]) {
+        [scenes addObject:(UIWindowScene *) scene];
+      }
+    }
+
+    result = bare_ui_kit__from_objects(env, state, scenes);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_scene_screen(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIWindowScene *scene = (__bridge UIWindowScene *) handle;
+
+    result = bare_foundation_bridge(env, state->registry, scene.screen);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_scene_activation_state(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIScene *scene = (__bridge UIScene *) handle;
+
+    err = js_create_int32(env, (int32_t) scene.activationState, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}

package/lib/scene.js

@@ -0,0 +1,48 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const retain = require('./retain')
+const wrap = require('./wrap')
+const UIKitScreen = require('./screen')
+
+module.exports = exports = class UIKitScene {
+  constructor(opts = {}) {
+    const { tag = null } = opts
+
+    this._tag = tag
+
+    this._token = binding.claim(this._tag, this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  static get connected() {
+    return binding.sceneConnected().map((tag) => wrap(UIKitScene, tag))
+  }
+
+  get screen() {
+    return retain(this, '_screen', UIKitScreen, binding.sceneScreen(this._tag))
+  }
+
+  get activationState() {
+    return binding.sceneActivationState(this._tag)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitScene }
+    }
+  }
+}
+
+exports.ACTIVATION_STATE = {
+  UNATTACHED: binding.SCENE_ACTIVATION_STATE_UNATTACHED,
+  FOREGROUND_ACTIVE: binding.SCENE_ACTIVATION_STATE_FOREGROUND_ACTIVE,
+  FOREGROUND_INACTIVE: binding.SCENE_ACTIVATION_STATE_FOREGROUND_INACTIVE,
+  BACKGROUND: binding.SCENE_ACTIVATION_STATE_BACKGROUND
+}

package/lib/scratch.js

@@ -0,0 +1,4 @@
+// Shared storage for getters that write into a buffer instead of building an
+// object. Each getter copies the values out straight away, so one buffer serves
+// all of them.
+module.exports = exports = new Float64Array(4)

package/lib/screen.d.ts

@@ -0,0 +1,26 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+
+/** A screen, as a `UIScreen`. */
+interface UIKitScreen {
+  /** The bounds in points. */
+  readonly bounds: { x: number; y: number; width: number; height: number }
+
+  /** The bounds in pixels. */
+  readonly nativeBounds: { x: number; y: number; width: number; height: number }
+
+  readonly scale: number
+
+  readonly nativeScale: number
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitScreen {
+  protected constructor()
+
+  static readonly mainScreen: UIKitScreen
+}
+
+export = UIKitScreen