bare-ui-kit 0.2.0 → 0.3.0

package/index.d.ts

@@ -0,0 +1,41 @@
+import ActivityIndicatorView = require('./lib/activity-indicator-view')
+import AttributedString = require('./lib/attributed-string')
+import BezierPath = require('./lib/bezier-path')
+import Color = require('./lib/color')
+import Font = require('./lib/font')
+import FontDescriptor = require('./lib/font-descriptor')
+import Image = require('./lib/image')
+import ImageView = require('./lib/image-view')
+import Label = require('./lib/label')
+import ParagraphStyle = require('./lib/paragraph-style')
+import Scene = require('./lib/scene')
+import Screen = require('./lib/screen')
+import ScrollView = require('./lib/scroll-view')
+import Switch = require('./lib/switch')
+import TextField = require('./lib/text-field')
+import TextView = require('./lib/text-view')
+import View = require('./lib/view')
+import ViewController = require('./lib/view-controller')
+import Window = require('./lib/window')
+
+export {
+  ActivityIndicatorView,
+  AttributedString,
+  BezierPath,
+  Color,
+  Font,
+  FontDescriptor,
+  Image,
+  ImageView,
+  Label,
+  ParagraphStyle,
+  Scene,
+  Screen,
+  ScrollView,
+  Switch,
+  TextField,
+  TextView,
+  View,
+  ViewController,
+  Window
+}

package/index.js

@@ -1,3 +1,19 @@
+exports.ActivityIndicatorView = require('./lib/activity-indicator-view')
+exports.AttributedString = require('./lib/attributed-string')
+exports.BezierPath = require('./lib/bezier-path')
+exports.Color = require('./lib/color')
+exports.Font = require('./lib/font')
+exports.FontDescriptor = require('./lib/font-descriptor')
+exports.Image = require('./lib/image')
+exports.ImageView = require('./lib/image-view')
+exports.Label = require('./lib/label')
+exports.ParagraphStyle = require('./lib/paragraph-style')
+exports.Scene = require('./lib/scene')
+exports.Screen = require('./lib/screen')
+exports.ScrollView = require('./lib/scroll-view')
+exports.Switch = require('./lib/switch')
+exports.TextField = require('./lib/text-field')
+exports.TextView = require('./lib/text-view')
 exports.View = require('./lib/view')
 exports.ViewController = require('./lib/view-controller')
 exports.Window = require('./lib/window')

package/lib/activity-indicator-view.d.ts

@@ -0,0 +1,29 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitView = require('./view')
+import UIKitColor = require('./color')
+
+/** A spinning busy indicator, as a `UIActivityIndicatorView`. */
+interface UIKitActivityIndicatorView extends UIKitView {
+  /** The size of the indicator, as a `STYLE` constant. */
+  style: number
+
+  get color(): UIKitColor | null
+  set color(color: Wrapper | null)
+
+  /** Whether the indicator is hidden while it is not spinning. */
+  hidesWhenStopped: boolean
+
+  /** Whether the indicator is spinning. */
+  animating: boolean
+}
+
+declare class UIKitActivityIndicatorView {
+  constructor(frame?: Partial<UIKitView.Rect>)
+
+  static readonly STYLE: {
+    readonly MEDIUM: number
+    readonly LARGE: number
+  }
+}
+
+export = UIKitActivityIndicatorView

package/lib/activity-indicator-view.h

@@ -0,0 +1,181 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_activity_indicator_view_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 4;
+  js_value_t *argv[4];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 4);
+
+  double x;
+  if (!bare_ui_kit__read_double(env, argv[0], "x", &x)) return NULL;
+
+  double y;
+  if (!bare_ui_kit__read_double(env, argv[1], "y", &y)) return NULL;
+
+  double width;
+  if (!bare_ui_kit__read_double(env, argv[2], "width", &width)) return NULL;
+
+  double height;
+  if (!bare_ui_kit__read_double(env, argv[3], "height", &height)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIActivityIndicatorView *handle = [[[UIActivityIndicatorView alloc]
+      initWithFrame:CGRectMake(x, y, width, height)] autorelease];
+
+    result = bare_foundation_bridge(env, state->registry, handle);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_activity_indicator_view_style(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 {
+    UIActivityIndicatorView *view = (__bridge UIActivityIndicatorView *) handle;
+
+    if (argc == 1) {
+      err = js_create_int32(env, (int32_t) view.activityIndicatorViewStyle, &result);
+      assert(err == 0);
+    } else {
+      int32_t style;
+      if (!bare_ui_kit__read_int32(env, argv[1], "style", &style)) return NULL;
+
+      view.activityIndicatorViewStyle = (UIActivityIndicatorViewStyle) style;
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_activity_indicator_view_color(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 {
+    UIActivityIndicatorView *view = (__bridge UIActivityIndicatorView *) handle;
+
+    if (argc == 1) {
+      result = bare_foundation_bridge(env, state->registry, view.color);
+    } else {
+      view.color = bare_foundation_to_object(env, state->registry, argv[1]);
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_activity_indicator_view_hides_when_stopped(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 {
+    UIActivityIndicatorView *view = (__bridge UIActivityIndicatorView *) handle;
+
+    if (argc == 1) {
+      err = js_get_boolean(env, view.hidesWhenStopped, &result);
+      assert(err == 0);
+    } else {
+      bool value;
+      if (!bare_ui_kit__read_bool(env, argv[1], "hidesWhenStopped", &value)) return NULL;
+
+      view.hidesWhenStopped = value;
+    }
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_activity_indicator_view_animating(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 {
+    UIActivityIndicatorView *view = (__bridge UIActivityIndicatorView *) handle;
+
+    if (argc == 1) {
+      err = js_get_boolean(env, view.animating, &result);
+      assert(err == 0);
+    } else {
+      bool value;
+      if (!bare_ui_kit__read_bool(env, argv[1], "animating", &value)) return NULL;
+
+      if (value) [view startAnimating];
+      else [view stopAnimating];
+    }
+  }
+
+  return result;
+}

package/lib/activity-indicator-view.js

@@ -0,0 +1,56 @@
+const binding = require('../binding')
+const { adopt } = require('./handle')
+const wrap = require('./wrap')
+const UIKitColor = require('./color')
+const UIKitView = require('./view')
+
+module.exports = exports = class UIKitActivityIndicatorView extends UIKitView {
+  _init(opts) {
+    const { x = 0, y = 0, width = 0, height = 0 } = opts
+
+    return binding.activityIndicatorViewInit(x, y, width, height)
+  }
+
+  get style() {
+    return binding.activityIndicatorViewStyle(this._tag)
+  }
+
+  set style(value) {
+    binding.activityIndicatorViewStyle(this._tag, value)
+  }
+
+  get color() {
+    return wrap(UIKitColor, binding.activityIndicatorViewColor(this._tag))
+  }
+
+  set color(value) {
+    binding.activityIndicatorViewColor(this._tag, value === null ? null : adopt(value))
+  }
+
+  get hidesWhenStopped() {
+    return binding.activityIndicatorViewHidesWhenStopped(this._tag)
+  }
+
+  set hidesWhenStopped(value) {
+    binding.activityIndicatorViewHidesWhenStopped(this._tag, value)
+  }
+
+  get animating() {
+    return binding.activityIndicatorViewAnimating(this._tag)
+  }
+
+  set animating(value) {
+    binding.activityIndicatorViewAnimating(this._tag, value)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitActivityIndicatorView }
+    }
+  }
+}
+
+exports.STYLE = {
+  MEDIUM: binding.ACTIVITY_INDICATOR_VIEW_STYLE_MEDIUM,
+  LARGE: binding.ACTIVITY_INDICATOR_VIEW_STYLE_LARGE
+}

package/lib/alert-action.d.ts

@@ -0,0 +1,33 @@
+import EventEmitter from 'bare-events'
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+
+/** A button in an alert, as a `UIAlertAction`. */
+interface UIKitAlertAction extends EventEmitter<UIKitAlertAction.Events> {
+  readonly title: string | null
+
+  readonly style: number
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitAlertAction {
+  /** `style` is a `STYLE` constant and defaults to `STYLE.DEFAULT`. */
+  constructor(opts?: { title?: string; style?: number })
+
+  static readonly STYLE: {
+    readonly DEFAULT: number
+    readonly CANCEL: number
+    readonly DESTRUCTIVE: number
+  }
+}
+
+declare namespace UIKitAlertAction {
+  export interface Events {
+    /** The button was pressed. */
+    selected: []
+  }
+}
+
+export = UIKitAlertAction

package/lib/alert-action.js

@@ -0,0 +1,48 @@
+const EventEmitter = require('bare-events')
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+
+// No mask: the handler is set when the action is made, so it always reports.
+module.exports = exports = class UIKitAlertAction extends EventEmitter {
+  constructor(opts = {}) {
+    super()
+
+    const { tag = null, title = '', style = exports.STYLE.DEFAULT } = opts
+
+    this._tag = tag === null ? binding.alertActionInit(title, style, this) : tag
+
+    this._token = binding.claim(this._tag, this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  get title() {
+    return binding.alertActionTitle(this._tag)
+  }
+
+  get style() {
+    return binding.alertActionStyle(this._tag)
+  }
+
+  _onselected() {
+    this.emit('selected')
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitAlertAction }
+    }
+  }
+}
+
+exports.STYLE = {
+  DEFAULT: binding.ALERT_ACTION_STYLE_DEFAULT,
+  CANCEL: binding.ALERT_ACTION_STYLE_CANCEL,
+  DESTRUCTIVE: binding.ALERT_ACTION_STYLE_DESTRUCTIVE
+}

package/lib/alert-controller.d.ts

@@ -0,0 +1,20 @@
+import UIKitViewController = require('./view-controller')
+import UIKitAlertAction = require('./alert-action')
+
+/** An alert or action sheet, as a `UIAlertController`. Show it with `present()`. */
+interface UIKitAlertController extends UIKitViewController {
+  /** Add a button. Listen for its `selected` event to know when it is pressed. */
+  addAction(action: UIKitAlertAction): this
+}
+
+declare class UIKitAlertController {
+  /** `preferredStyle` is a `STYLE` constant and defaults to `STYLE.ALERT`. */
+  constructor(opts?: { title?: string; message?: string | null; preferredStyle?: number })
+
+  static readonly STYLE: {
+    readonly ACTION_SHEET: number
+    readonly ALERT: number
+  }
+}
+
+export = UIKitAlertController

package/lib/alert-controller.h

@@ -0,0 +1,199 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+// An action gets its handler when it is made, so it always reports and has no
+// mask.
+@interface BareAlertActionHandler : NSObject {
+@public
+  js_env_t *env;
+  js_ref_t *ctx;
+}
+@end
+
+@implementation BareAlertActionHandler
+
+- (void)dealloc {
+  int err;
+
+  err = js_delete_reference(env, ctx);
+  assert(err == 0);
+
+  [super dealloc];
+}
+
+- (void)selected {
+  bare_ui_kit__emit(env, ctx, "_onselected");
+}
+
+@end
+
+static js_value_t *
+bare_ui_kit_alert_action_init(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);
+
+  double style;
+  if (!bare_ui_kit__read_double(env, argv[1], "style", &style)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    NSString *title = bare_ui_kit__to_string(env, argv[0]);
+
+    BareAlertActionHandler *handler = [[BareAlertActionHandler alloc] init];
+
+    handler->env = env;
+
+    // Weak, so the native object does not keep its own wrapper alive.
+    err = js_create_reference(env, argv[2], 0, &handler->ctx);
+    assert(err == 0);
+
+    UIAlertAction *action = [UIAlertAction actionWithTitle:title
+                                                     style:(UIAlertActionStyle) style
+                                                   handler:^(UIAlertAction *selected) {
+                                                     [handler selected];
+                                                   }];
+
+    // The action owns the copied block, and the block retains what it captured,
+    // so the handler outlives this scope.
+    [handler release];
+
+    result = bare_foundation_bridge(env, state->registry, action);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_alert_action_title(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 {
+    UIAlertAction *action = (__bridge UIAlertAction *) handle;
+
+    result = bare_ui_kit__from_string(env, action.title);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_alert_action_style(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 {
+    UIAlertAction *action = (__bridge UIAlertAction *) handle;
+
+    err = js_create_int32(env, (int32_t) action.style, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_alert_controller_init(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);
+
+  double style;
+  if (!bare_ui_kit__read_double(env, argv[2], "preferred_style", &style)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    NSString *title = bare_ui_kit__to_string(env, argv[0]);
+
+    js_value_t *message = argv[1];
+
+    js_value_type_t type;
+    err = js_typeof(env, message, &type);
+    assert(err == 0);
+
+    UIAlertController *controller =
+      [UIAlertController alertControllerWithTitle:title
+                                          message:type == js_string ? bare_ui_kit__to_string(env, message) : nil
+                                   preferredStyle:(UIAlertControllerStyle) style];
+
+    result = bare_foundation_bridge(env, state->registry, controller);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_alert_controller_add_action(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;
+
+  void *action;
+  if (bare_foundation_read_tag(env, state->registry, argv[1], "action", &action) < 0) return NULL;
+
+  @autoreleasepool {
+    UIAlertController *controller = (__bridge UIAlertController *) handle;
+
+    [controller addAction:(__bridge UIAlertAction *) action];
+  }
+
+  return NULL;
+}

package/lib/alert-controller.js

@@ -0,0 +1,33 @@
+const binding = require('../binding')
+const { adopt } = require('./handle')
+const UIKitViewController = require('./view-controller')
+
+module.exports = exports = class UIKitAlertController extends UIKitViewController {
+  constructor(opts = {}) {
+    const { title = '', message = null, preferredStyle = exports.STYLE.ALERT } = opts
+
+    super({ tag: binding.alertControllerInit(title, message, preferredStyle) })
+
+    this._actions = new Set()
+  }
+
+  addAction(action) {
+    binding.alertControllerAddAction(this._tag, adopt(action))
+
+    // Keep the wrapper, so its listeners live as long as the controller.
+    this._actions.add(action)
+
+    return this
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitAlertController }
+    }
+  }
+}
+
+exports.STYLE = {
+  ACTION_SHEET: binding.ALERT_CONTROLLER_STYLE_ACTION_SHEET,
+  ALERT: binding.ALERT_CONTROLLER_STYLE_ALERT
+}