bare-ui-kit 0.2.0 → 0.3.0

package/lib/view-controller.h

@@ -6,10 +6,20 @@
 
 #import "bridging.h"
 
-@interface BareViewController : UIViewController {
+// The controller lays its view out to fill the window, so this is where a size
+// change is seen. Watching every view would report the same layout once per
+// view.
+enum {
+  bare_ui_kit_view_controller_event_did_layout_subviews = 1 << 0,
+  bare_ui_kit_view_controller_event_safe_area_insets_did_change = 1 << 1,
+};
+
+@interface BareViewController : UIViewController <BareEventTarget> {
 @public
   js_env_t *env;
   js_ref_t *ctx;
+
+  int32_t mask;
 }
 
 @end
@@ -25,6 +35,30 @@
   [super dealloc];
 }
 
+- (int32_t)eventMask {
+  return mask;
+}
+
+- (void)setEventMask:(int32_t)value {
+  mask = value;
+}
+
+- (void)viewDidLayoutSubviews {
+  [super viewDidLayoutSubviews];
+
+  if ((mask & bare_ui_kit_view_controller_event_did_layout_subviews) == 0) return;
+
+  bare_ui_kit__emit(env, ctx, "_ondidlayoutsubviews");
+}
+
+- (void)viewSafeAreaInsetsDidChange {
+  [super viewSafeAreaInsetsDidChange];
+
+  if ((mask & bare_ui_kit_view_controller_event_safe_area_insets_did_change) == 0) return;
+
+  bare_ui_kit__emit(env, ctx, "_onsafeareainsetsdidchange");
+}
+
 @end
 
 static js_value_t *
@@ -34,7 +68,8 @@ bare_ui_kit_view_controller_init(js_env_t *env, js_callback_info_t *info) {
   size_t argc = 1;
   js_value_t *argv[1];
 
-  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
   assert(err == 0);
 
   assert(argc == 1);
@@ -42,20 +77,82 @@ bare_ui_kit_view_controller_init(js_env_t *env, js_callback_info_t *info) {
   js_value_t *result;
 
   @autoreleasepool {
-    BareViewController *handle = [[BareViewController alloc] init];
+    BareViewController *handle = [[[BareViewController alloc] init] autorelease];
 
-    err = js_create_external(env, (void *) CFBridgingRetain(handle), bare_ui_kit__on_bridged_release, NULL, &result);
-    assert(err == 0);
+    result = bare_foundation_bridge(env, state->registry, handle);
 
     handle->env = env;
 
-    err = js_create_reference(env, argv[0], 1, &handle->ctx);
+    // Weak, so the native object does not keep its own wrapper alive. Events
+    // are dropped once the wrapper is collected.
+    err = js_create_reference(env, argv[0], 0, &handle->ctx);
     assert(err == 0);
   }
 
   return result;
 }
 
+static js_value_t *
+bare_ui_kit_view_controller_present(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  void *presented;
+  if (bare_foundation_read_tag(env, state->registry, argv[1], "presented", &presented) < 0) return NULL;
+
+  bool animated;
+  if (!bare_ui_kit__read_bool(env, argv[2], "animated", &animated)) return NULL;
+
+  @autoreleasepool {
+    UIViewController *controller = (__bridge UIViewController *) handle;
+
+    [controller presentViewController:(__bridge UIViewController *) presented
+                             animated:animated
+                           completion:nil];
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ui_kit_view_controller_dismiss(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 == 2);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  bool animated;
+  if (!bare_ui_kit__read_bool(env, argv[1], "animated", &animated)) return NULL;
+
+  @autoreleasepool {
+    UIViewController *controller = (__bridge UIViewController *) handle;
+
+    [controller dismissViewControllerAnimated:animated completion:nil];
+  }
+
+  return NULL;
+}
+
 static js_value_t *
 bare_ui_kit_view_controller_view(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -63,14 +160,14 @@ bare_ui_kit_view_controller_view(js_env_t *env, js_callback_info_t *info) {
   size_t argc = 2;
   js_value_t *argv[2];
 
-  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  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;
-  err = js_get_value_external(env, argv[0], &handle);
-  assert(err == 0);
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
 
   js_value_t *result = NULL;
 
@@ -78,18 +175,9 @@ bare_ui_kit_view_controller_view(js_env_t *env, js_callback_info_t *info) {
     UIViewController *view_controller = (__bridge UIViewController *) handle;
 
     if (argc == 1) {
-      UIView *view = view_controller.view;
-
-      err = js_create_external(env, (void *) CFBridgingRetain(view), bare_ui_kit__on_bridged_release, NULL, &result);
-      assert(err == 0);
+      result = bare_foundation_bridge(env, state->registry, view_controller.view);
     } else {
-      void *handle;
-      err = js_get_value_external(env, argv[1], &handle);
-      assert(err == 0);
-
-      UIView *view = (__bridge UIView *) handle;
-
-      view_controller.view = view;
+      view_controller.view = bare_foundation_to_object(env, state->registry, argv[1]);
     }
   }
 

package/lib/view-controller.js

@@ -1,20 +1,60 @@
 const EventEmitter = require('bare-events')
 const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const { adopt } = require('./handle')
+const observe = require('./events')
+const retain = require('./retain')
 const UIKitView = require('./view')
 
-module.exports = class UIKitViewController extends EventEmitter {
-  constructor(handle = null) {
+module.exports = exports = class UIKitViewController extends EventEmitter {
+  constructor(opts = {}) {
     super()
 
-    this._handle = handle || binding.viewControllerInit(this)
+    const { tag = null } = opts
+
+    this._tag = tag === null ? binding.viewControllerInit(this) : tag
+    this._view = null
+
+    this._token = binding.claim(this._tag, this)
+
+    observe(this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
   }
 
   get view() {
-    return new UIKitView(binding.viewControllerView(this._handle))
+    return retain(this, '_view', UIKitView, binding.viewControllerView(this._tag))
   }
 
   set view(view) {
-    binding.viewControllerView(this._handle, view._handle)
+    binding.viewControllerView(this._tag, adopt(view))
+    this._view = view
+  }
+
+  present(controller, animated = true) {
+    binding.viewControllerPresent(this._tag, adopt(controller), animated)
+
+    return this
+  }
+
+  dismiss(animated = true) {
+    binding.viewControllerDismiss(this._tag, animated)
+
+    return this
+  }
+
+  _ondidlayoutsubviews() {
+    this.emit('didLayoutSubviews')
+  }
+
+  _onsafeareainsetsdidchange() {
+    this.emit('safeAreaInsetsDidChange')
   }
 
   [Symbol.for('bare.inspect')]() {
@@ -23,3 +63,8 @@ module.exports = class UIKitViewController extends EventEmitter {
     }
   }
 }
+
+exports._events = {
+  didLayoutSubviews: binding.VIEW_CONTROLLER_EVENT_DID_LAYOUT_SUBVIEWS,
+  safeAreaInsetsDidChange: binding.VIEW_CONTROLLER_EVENT_SAFE_AREA_INSETS_DID_CHANGE
+}

package/lib/view.d.ts

@@ -0,0 +1,158 @@
+import EventEmitter from 'bare-events'
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitColor = require('./color')
+
+/**
+ * The base of every view, as a `UIView`. Views that are added to a view are kept alive by it, so
+ * their listeners keep working.
+ */
+interface UIKitView<
+  M extends Record<keyof M, unknown[]> = UIKitView.Events
+> extends EventEmitter<M> {
+  /** The position and size of the view in its superview. Missing fields are 0. */
+  get frame(): UIKitView.Rect
+  set frame(frame: Partial<UIKitView.Rect>)
+
+  /** The position and size of the view in its own coordinates. Missing fields are 0. */
+  get bounds(): UIKitView.Rect
+  set bounds(bounds: Partial<UIKitView.Rect>)
+
+  hidden: boolean
+
+  /** How opaque the view is, from 0 to 1. */
+  alpha: number
+
+  /** How the content is fitted to the view, as a `CONTENT_MODE` constant. */
+  contentMode: number
+
+  clipsToBounds: boolean
+
+  userInteractionEnabled: boolean
+
+  get backgroundColor(): UIKitColor | null
+  set backgroundColor(color: Wrapper | null)
+
+  get tintColor(): UIKitColor | null
+  set tintColor(color: Wrapper | null)
+
+  /** How far the safe area is inset from each edge of the view. */
+  readonly safeAreaInsets: UIKitView.Insets
+
+  readonly superview: UIKitView | null
+
+  readonly subviews: UIKitView[]
+
+  /** Add `view` on top of the other subviews. It can come from another addon. */
+  addSubview(view: Wrapper): this
+
+  insertSubviewAtIndex(view: Wrapper, index: number): this
+
+  insertSubviewBelowSubview(view: Wrapper, sibling: Wrapper): this
+
+  insertSubviewAboveSubview(view: Wrapper, sibling: Wrapper): this
+
+  removeFromSuperview(): this
+
+  setNeedsLayout(): this
+
+  setNeedsDisplay(): this
+
+  /**
+   * Stop editing anywhere inside the view, which hides the keyboard. With `force`, the default,
+   * editing stops even if a field asks to keep it. Returns whether editing stopped.
+   */
+  endEditing(force?: boolean): boolean
+
+  /** Convert a point in the view to the coordinates of `view`, or of the window when `null`. */
+  convertPointToView(x: number, y: number, view?: UIKitView | null): { x: number; y: number }
+
+  /** Convert a point in `view`, or in the window when `null`, to the coordinates of the view. */
+  convertPointFromView(x: number, y: number, view?: UIKitView | null): { x: number; y: number }
+
+  /** The size the view would like to be, within `width` by `height`. */
+  sizeThatFits(width: number, height: number): { width: number; height: number }
+
+  /** Resize the view to the size it would like to be. */
+  sizeToFit(): this
+
+  /** Take the keyboard focus. Returns whether the view took it. */
+  becomeFirstResponder(): boolean
+
+  /** Give up the keyboard focus. Returns whether the view gave it up. */
+  resignFirstResponder(): boolean
+
+  /** Whether the view has the keyboard focus. */
+  readonly firstResponder: boolean
+
+  /** Force light or dark mode for the view, as a `USER_INTERFACE_STYLE` constant. */
+  overrideUserInterfaceStyle: number
+
+  /** Whether the view is drawn in light or dark mode, as a `USER_INTERFACE_STYLE` constant. */
+  readonly userInterfaceStyle: number
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitView<M extends Record<keyof M, unknown[]> = UIKitView.Events> {
+  /** Create a view with `frame`. Missing fields are 0. */
+  constructor(frame?: Partial<UIKitView.Rect>)
+
+  static readonly USER_INTERFACE_STYLE: {
+    readonly UNSPECIFIED: number
+    readonly LIGHT: number
+    readonly DARK: number
+  }
+
+  static readonly CONTENT_MODE: {
+    readonly SCALE_TO_FILL: number
+    readonly SCALE_ASPECT_FIT: number
+    readonly SCALE_ASPECT_FILL: number
+    readonly REDRAW: number
+    readonly CENTER: number
+    readonly TOP: number
+    readonly BOTTOM: number
+    readonly LEFT: number
+    readonly RIGHT: number
+    readonly TOP_LEFT: number
+    readonly TOP_RIGHT: number
+    readonly BOTTOM_LEFT: number
+    readonly BOTTOM_RIGHT: number
+  }
+}
+
+declare namespace UIKitView {
+  export interface Rect {
+    x: number
+    y: number
+    width: number
+    height: number
+  }
+
+  export interface Insets {
+    top: number
+    left: number
+    bottom: number
+    right: number
+  }
+
+  /** A touch. `pointerId` tells fingers apart. */
+  export interface Touch {
+    x: number
+    y: number
+    pointerId: number
+  }
+
+  export interface Events {
+    touchesBegan: [touch: Touch]
+    touchesMoved: [touch: Touch]
+    touchesEnded: [touch: Touch]
+    touchesCancelled: [touch: Touch]
+
+    /** A trait changed, such as light or dark mode. */
+    traitChange: []
+  }
+}
+
+export = UIKitView