bare-ui-kit 0.2.0 → 0.3.0

package/lib/color.h

@@ -0,0 +1,286 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+// The list every system colour is generated from: the ids below, the switch in
+// `bare_ui_kit_color_system()`, and the constants in `binding.m`.
+#define BARE_UI_KIT_COLORS(V) \
+  V(BLACK, blackColor) \
+  V(WHITE, whiteColor) \
+  V(CLEAR, clearColor) \
+  V(LABEL, labelColor) \
+  V(SECONDARY_LABEL, secondaryLabelColor) \
+  V(TERTIARY_LABEL, tertiaryLabelColor) \
+  V(QUATERNARY_LABEL, quaternaryLabelColor) \
+  V(PLACEHOLDER_TEXT, placeholderTextColor) \
+  V(SEPARATOR, separatorColor) \
+  V(OPAQUE_SEPARATOR, opaqueSeparatorColor) \
+  V(LINK, linkColor) \
+  V(SYSTEM_BACKGROUND, systemBackgroundColor) \
+  V(SECONDARY_SYSTEM_BACKGROUND, secondarySystemBackgroundColor) \
+  V(TERTIARY_SYSTEM_BACKGROUND, tertiarySystemBackgroundColor) \
+  V(SYSTEM_GROUPED_BACKGROUND, systemGroupedBackgroundColor) \
+  V(SYSTEM_FILL, systemFillColor) \
+  V(TINT, tintColor) \
+  V(SYSTEM_RED, systemRedColor) \
+  V(SYSTEM_ORANGE, systemOrangeColor) \
+  V(SYSTEM_YELLOW, systemYellowColor) \
+  V(SYSTEM_GREEN, systemGreenColor) \
+  V(SYSTEM_MINT, systemMintColor) \
+  V(SYSTEM_TEAL, systemTealColor) \
+  V(SYSTEM_CYAN, systemCyanColor) \
+  V(SYSTEM_BLUE, systemBlueColor) \
+  V(SYSTEM_INDIGO, systemIndigoColor) \
+  V(SYSTEM_PURPLE, systemPurpleColor) \
+  V(SYSTEM_PINK, systemPinkColor) \
+  V(SYSTEM_BROWN, systemBrownColor) \
+  V(SYSTEM_GRAY, systemGrayColor)
+
+enum {
+#define V(name, selector) bare_ui_kit_color_##name,
+  BARE_UI_KIT_COLORS(V)
+#undef V
+};
+
+static js_value_t *
+bare_ui_kit_color_system(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);
+
+  int32_t id;
+  if (!bare_ui_kit__read_int32(env, argv[0], "id", &id)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIColor *color = nil;
+
+    switch (id) {
+#define V(name, selector) \
+  case bare_ui_kit_color_##name: \
+    color = [UIColor selector]; \
+    break;
+      BARE_UI_KIT_COLORS(V)
+#undef V
+    }
+
+    result = bare_foundation_bridge(env, state->registry, color);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_color_rgb(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 red;
+  if (!bare_ui_kit__read_double(env, argv[0], "red", &red)) return NULL;
+
+  double green;
+  if (!bare_ui_kit__read_double(env, argv[1], "green", &green)) return NULL;
+
+  double blue;
+  if (!bare_ui_kit__read_double(env, argv[2], "blue", &blue)) return NULL;
+
+  double alpha;
+  if (!bare_ui_kit__read_double(env, argv[3], "alpha", &alpha)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIColor colorWithRed:red green:green blue:blue alpha:alpha]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_color_hsb(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 hue;
+  if (!bare_ui_kit__read_double(env, argv[0], "hue", &hue)) return NULL;
+
+  double saturation;
+  if (!bare_ui_kit__read_double(env, argv[1], "saturation", &saturation)) return NULL;
+
+  double brightness;
+  if (!bare_ui_kit__read_double(env, argv[2], "brightness", &brightness)) return NULL;
+
+  double alpha;
+  if (!bare_ui_kit__read_double(env, argv[3], "alpha", &alpha)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIColor colorWithHue:hue saturation:saturation brightness:brightness alpha:alpha]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_color_white(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);
+
+  double white;
+  if (!bare_ui_kit__read_double(env, argv[0], "white", &white)) return NULL;
+
+  double alpha;
+  if (!bare_ui_kit__read_double(env, argv[1], "alpha", &alpha)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIColor colorWithWhite:white alpha:alpha]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_color_with_alpha_component(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;
+
+  double alpha;
+  if (!bare_ui_kit__read_double(env, argv[1], "alpha", &alpha)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIColor *color = (__bridge UIColor *) handle;
+
+    result = bare_foundation_bridge(env, state->registry, [color colorWithAlphaComponent:alpha]);
+  }
+
+  return result;
+}
+
+// A colour that has no RGBA value, such as a pattern, reports zeroes.
+static js_value_t *
+bare_ui_kit_color_components_into(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;
+
+  uint32_t offset;
+  if (!bare_ui_kit__read_uint32(env, argv[2], "offset", &offset)) return NULL;
+
+  double *out;
+
+  if (!bare_ui_kit__buffer(env, argv[1], offset, 4, &out)) {
+    err = js_throw_type_error(env, NULL, "Expected an array buffer with room for 4 doubles");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  @autoreleasepool {
+    UIColor *color = (__bridge UIColor *) handle;
+
+    CGFloat red = 0, green = 0, blue = 0, alpha = 0;
+
+    [color getRed:&red green:&green blue:&blue alpha:&alpha];
+
+    out[0] = red;
+    out[1] = green;
+    out[2] = blue;
+    out[3] = alpha;
+  }
+
+  return NULL;
+}
+
+static void
+bare_ui_kit_color_components_into_typed(js_value_t *receiver, int32_t bare_tag, js_value_t *bare_buffer, uint32_t bare_offset, js_typed_callback_info_t *info) {
+  int err;
+
+  bare_ui_kit_state_t *state;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, (void **) &state);
+  assert(err == 0);
+
+  id bare_object = bare_foundation_object(state->registry, bare_tag);
+
+  if (bare_object == nil) return;
+
+  double *out;
+
+  if (!bare_ui_kit__buffer(env, bare_buffer, bare_offset, 4, &out)) return;
+
+  @autoreleasepool {
+    UIColor *color = (UIColor *) bare_object;
+
+    CGFloat red = 0, green = 0, blue = 0, alpha = 0;
+
+    [color getRed:&red green:&green blue:&blue alpha:&alpha];
+
+    out[0] = red;
+    out[1] = green;
+    out[2] = blue;
+    out[3] = alpha;
+  }
+}

package/lib/color.js

@@ -0,0 +1,170 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const scratch = require('./scratch')
+const wrap = require('./wrap')
+
+module.exports = exports = class UIKitColor {
+  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 rgb(red, green, blue, alpha = 1) {
+    return new UIKitColor({ tag: binding.colorRGB(red, green, blue, alpha) })
+  }
+
+  static hsb(hue, saturation, brightness, alpha = 1) {
+    return new UIKitColor({ tag: binding.colorHSB(hue, saturation, brightness, alpha) })
+  }
+
+  static white(white, alpha = 1) {
+    return new UIKitColor({ tag: binding.colorWhite(white, alpha) })
+  }
+
+  static get blackColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_BLACK))
+  }
+
+  static get whiteColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_WHITE))
+  }
+
+  static get clearColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_CLEAR))
+  }
+
+  static get labelColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_LABEL))
+  }
+
+  static get secondaryLabelColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SECONDARY_LABEL))
+  }
+
+  static get tertiaryLabelColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_TERTIARY_LABEL))
+  }
+
+  static get quaternaryLabelColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_QUATERNARY_LABEL))
+  }
+
+  static get placeholderTextColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_PLACEHOLDER_TEXT))
+  }
+
+  static get separatorColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SEPARATOR))
+  }
+
+  static get opaqueSeparatorColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_OPAQUE_SEPARATOR))
+  }
+
+  static get linkColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_LINK))
+  }
+
+  static get systemBackgroundColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_BACKGROUND))
+  }
+
+  static get secondarySystemBackgroundColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SECONDARY_SYSTEM_BACKGROUND))
+  }
+
+  static get tertiarySystemBackgroundColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_TERTIARY_SYSTEM_BACKGROUND))
+  }
+
+  static get systemGroupedBackgroundColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_GROUPED_BACKGROUND))
+  }
+
+  static get systemFillColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_FILL))
+  }
+
+  static get tintColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_TINT))
+  }
+
+  static get systemRedColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_RED))
+  }
+
+  static get systemOrangeColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_ORANGE))
+  }
+
+  static get systemYellowColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_YELLOW))
+  }
+
+  static get systemGreenColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_GREEN))
+  }
+
+  static get systemMintColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_MINT))
+  }
+
+  static get systemTealColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_TEAL))
+  }
+
+  static get systemCyanColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_CYAN))
+  }
+
+  static get systemBlueColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_BLUE))
+  }
+
+  static get systemIndigoColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_INDIGO))
+  }
+
+  static get systemPurpleColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_PURPLE))
+  }
+
+  static get systemPinkColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_PINK))
+  }
+
+  static get systemBrownColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_BROWN))
+  }
+
+  static get systemGrayColor() {
+    return wrap(UIKitColor, binding.colorSystem(binding.COLOR_SYSTEM_GRAY))
+  }
+
+  get components() {
+    binding.colorComponentsInto(this._tag, scratch.buffer, 0)
+
+    return { red: scratch[0], green: scratch[1], blue: scratch[2], alpha: scratch[3] }
+  }
+
+  withAlphaComponent(alpha) {
+    return wrap(UIKitColor, binding.colorWithAlphaComponent(this._tag, alpha))
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitColor }
+    }
+  }
+}

package/lib/events.js

@@ -0,0 +1,35 @@
+const binding = require('../binding')
+
+// The mask follows the listeners, so native code only calls into JavaScript
+// when something listens. The map is inherited, so a subclass keeps the events
+// of its parent.
+module.exports = exports = function observe(target) {
+  const events = target.constructor._events
+
+  if (events === undefined) return
+
+  let mask = target.constructor._always || 0
+
+  if (mask !== 0) binding.eventMask(target._tag, mask)
+
+  target.on('newListener', (name) => {
+    const bit = events[name]
+
+    if (bit === undefined || (mask & bit) !== 0) return
+
+    mask |= bit
+
+    binding.eventMask(target._tag, mask)
+  })
+
+  target.on('removeListener', (name) => {
+    const bit = events[name]
+
+    if (bit === undefined || (mask & bit) === 0) return
+    if (target.listenerCount(name) > 0) return
+
+    mask &= ~bit
+
+    binding.eventMask(target._tag, mask)
+  })
+}

package/lib/font-descriptor.d.ts

@@ -0,0 +1,30 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+
+/** A description of a font, as a `UIFontDescriptor`. */
+interface UIKitFontDescriptor {
+  /** The traits of the font, as `SYMBOLIC_TRAITS` flags combined with `|`. */
+  readonly symbolicTraits: number
+
+  /** The same font with `traits`, or `null` if it has no such variant. */
+  withSymbolicTraits(traits: number): UIKitFontDescriptor | null
+
+  withFamily(family: string): UIKitFontDescriptor | null
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitFontDescriptor {
+  protected constructor()
+
+  static readonly SYMBOLIC_TRAITS: {
+    readonly ITALIC: number
+    readonly BOLD: number
+    readonly EXPANDED: number
+    readonly CONDENSED: number
+    readonly MONO_SPACE: number
+  }
+}
+
+export = UIKitFontDescriptor

package/lib/font-descriptor.h

@@ -0,0 +1,96 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_font_descriptor_symbolic_traits(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 {
+    UIFontDescriptor *descriptor = (__bridge UIFontDescriptor *) handle;
+
+    err = js_create_uint32(env, descriptor.symbolicTraits, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_descriptor_with_symbolic_traits(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;
+
+  uint32_t traits;
+  if (!bare_ui_kit__read_uint32(env, argv[1], "traits", &traits)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIFontDescriptor *descriptor = (__bridge UIFontDescriptor *) handle;
+
+    result = bare_foundation_bridge(
+      env, state->registry, [descriptor fontDescriptorWithSymbolicTraits:(UIFontDescriptorSymbolicTraits) traits]
+    );
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_descriptor_with_family(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;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIFontDescriptor *descriptor = (__bridge UIFontDescriptor *) handle;
+
+    NSString *family = bare_ui_kit__to_string(env, argv[1]);
+
+    result = bare_foundation_bridge(env, state->registry, [descriptor fontDescriptorWithFamily:family]);
+  }
+
+  return result;
+}

package/lib/font-descriptor.js

@@ -0,0 +1,47 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const wrap = require('./wrap')
+
+module.exports = exports = class UIKitFontDescriptor {
+  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)
+  }
+
+  get symbolicTraits() {
+    return binding.fontDescriptorSymbolicTraits(this._tag)
+  }
+
+  withSymbolicTraits(traits) {
+    return wrap(UIKitFontDescriptor, binding.fontDescriptorWithSymbolicTraits(this._tag, traits))
+  }
+
+  withFamily(family) {
+    return wrap(UIKitFontDescriptor, binding.fontDescriptorWithFamily(this._tag, family))
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitFontDescriptor }
+    }
+  }
+}
+
+exports.SYMBOLIC_TRAITS = {
+  ITALIC: binding.FONT_DESCRIPTOR_TRAIT_ITALIC,
+  BOLD: binding.FONT_DESCRIPTOR_TRAIT_BOLD,
+  EXPANDED: binding.FONT_DESCRIPTOR_TRAIT_EXPANDED,
+  CONDENSED: binding.FONT_DESCRIPTOR_TRAIT_CONDENSED,
+  MONO_SPACE: binding.FONT_DESCRIPTOR_TRAIT_MONO_SPACE
+}

package/lib/font-metrics.d.ts

@@ -0,0 +1,38 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitFont = require('./font')
+
+/** Scales fonts and lengths for the text size the user chose, as a `UIFontMetrics`. */
+interface UIKitFontMetrics {
+  scaledValueForValue(value: number): number
+
+  scaledFontForFont(font: UIKitFont): UIKitFont
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitFontMetrics {
+  protected constructor()
+
+  static readonly defaultMetrics: UIKitFontMetrics
+
+  /** The metrics for a `FONT_TEXT_STYLE`. */
+  static metricsForTextStyle(textStyle: string): UIKitFontMetrics
+
+  static readonly FONT_TEXT_STYLE: {
+    readonly LARGE_TITLE: string
+    readonly TITLE1: string
+    readonly TITLE2: string
+    readonly TITLE3: string
+    readonly HEADLINE: string
+    readonly SUBHEADLINE: string
+    readonly BODY: string
+    readonly CALLOUT: string
+    readonly FOOTNOTE: string
+    readonly CAPTION1: string
+    readonly CAPTION2: string
+  }
+}
+
+export = UIKitFontMetrics