bare-ui-kit 0.2.0 → 0.3.0

package/lib/font-metrics.h

@@ -0,0 +1,109 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_font_metrics_default_metrics(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, [UIFontMetrics defaultMetrics]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_metrics_for_text_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);
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    NSString *style = bare_ui_kit__to_string(env, argv[0]);
+
+    result = bare_foundation_bridge(env, state->registry, [UIFontMetrics metricsForTextStyle:style]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_metrics_scaled_value_for_value(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 value;
+  if (!bare_ui_kit__read_double(env, argv[1], "value", &value)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIFontMetrics *metrics = (__bridge UIFontMetrics *) handle;
+
+    err = js_create_double(env, [metrics scaledValueForValue:value], &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_metrics_scaled_font_for_font(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 *font;
+  if (bare_foundation_read_tag(env, state->registry, argv[1], "font", &font) < 0) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIFontMetrics *metrics = (__bridge UIFontMetrics *) handle;
+
+    result = bare_foundation_bridge(env, state->registry, [metrics scaledFontForFont:(__bridge UIFont *) font]);
+  }
+
+  return result;
+}

package/lib/font-metrics.js

@@ -0,0 +1,58 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const wrap = require('./wrap')
+const UIKitFont = require('./font')
+
+module.exports = exports = class UIKitFontMetrics {
+  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 defaultMetrics() {
+    return wrap(UIKitFontMetrics, binding.fontMetricsDefaultMetrics())
+  }
+
+  static metricsForTextStyle(textStyle) {
+    return wrap(UIKitFontMetrics, binding.fontMetricsForTextStyle(textStyle))
+  }
+
+  scaledValueForValue(value) {
+    return binding.fontMetricsScaledValueForValue(this._tag, value)
+  }
+
+  scaledFontForFont(font) {
+    return wrap(UIKitFont, binding.fontMetricsScaledFontForFont(this._tag, font._tag))
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitFontMetrics }
+    }
+  }
+}
+
+exports.FONT_TEXT_STYLE = {
+  LARGE_TITLE: binding.FONT_TEXT_STYLE_LARGE_TITLE,
+  TITLE1: binding.FONT_TEXT_STYLE_TITLE1,
+  TITLE2: binding.FONT_TEXT_STYLE_TITLE2,
+  TITLE3: binding.FONT_TEXT_STYLE_TITLE3,
+  HEADLINE: binding.FONT_TEXT_STYLE_HEADLINE,
+  SUBHEADLINE: binding.FONT_TEXT_STYLE_SUBHEADLINE,
+  BODY: binding.FONT_TEXT_STYLE_BODY,
+  CALLOUT: binding.FONT_TEXT_STYLE_CALLOUT,
+  FOOTNOTE: binding.FONT_TEXT_STYLE_FOOTNOTE,
+  CAPTION1: binding.FONT_TEXT_STYLE_CAPTION1,
+  CAPTION2: binding.FONT_TEXT_STYLE_CAPTION2
+}

package/lib/font.d.ts

@@ -0,0 +1,59 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitFontDescriptor = require('./font-descriptor')
+
+/** A font, as a `UIFont`. Sizes are in points. */
+interface UIKitFont {
+  readonly fontDescriptor: UIKitFontDescriptor
+
+  readonly fontName: string
+
+  readonly familyName: string
+
+  readonly pointSize: number
+
+  readonly ascender: number
+
+  readonly descender: number
+
+  readonly capHeight: number
+
+  readonly xHeight: number
+
+  readonly leading: number
+
+  readonly lineHeight: number
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitFont {
+  protected constructor()
+
+  /** The system font. `weight` is a `WEIGHT` constant and defaults to regular. */
+  static systemFont(size: number, weight?: number): UIKitFont
+
+  static boldSystemFont(size: number): UIKitFont
+
+  static monospacedSystemFont(size: number, weight?: number): UIKitFont
+
+  /** The font called `name`, or `null` if it is not installed. */
+  static withName(name: string, size: number): UIKitFont | null
+
+  static withDescriptor(descriptor: UIKitFontDescriptor, size: number): UIKitFont
+
+  static readonly WEIGHT: {
+    readonly ULTRA_LIGHT: number
+    readonly THIN: number
+    readonly LIGHT: number
+    readonly REGULAR: number
+    readonly MEDIUM: number
+    readonly SEMIBOLD: number
+    readonly BOLD: number
+    readonly HEAVY: number
+    readonly BLACK: number
+  }
+}
+
+export = UIKitFont

package/lib/font.h

@@ -0,0 +1,424 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_font_system_font(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 size;
+  if (!bare_ui_kit__read_double(env, argv[0], "size", &size)) return NULL;
+
+  double weight;
+  if (!bare_ui_kit__read_double(env, argv[1], "weight", &weight)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIFont systemFontOfSize:size weight:weight]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_bold_system_font(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);
+
+  double size;
+  if (!bare_ui_kit__read_double(env, argv[0], "size", &size)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIFont boldSystemFontOfSize:size]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_monospaced_system_font(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 size;
+  if (!bare_ui_kit__read_double(env, argv[0], "size", &size)) return NULL;
+
+  double weight;
+  if (!bare_ui_kit__read_double(env, argv[1], "weight", &weight)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    result = bare_foundation_bridge(env, state->registry, [UIFont monospacedSystemFontOfSize:size weight:weight]);
+  }
+
+  return result;
+}
+
+// A family that is not installed has no font. That is not an error, and the
+// caller falls back to the system font.
+static js_value_t *
+bare_ui_kit_font_with_name(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 size;
+  if (!bare_ui_kit__read_double(env, argv[1], "size", &size)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    NSString *name = bare_ui_kit__to_string(env, argv[0]);
+
+    result = bare_foundation_bridge(env, state->registry, [UIFont fontWithName:name size:size]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_font_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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    result = bare_ui_kit__from_string(env, font.fontName);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_family_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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    result = bare_ui_kit__from_string(env, font.familyName);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_point_size(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    err = js_create_double(env, font.pointSize, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_ascender(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    err = js_create_double(env, font.ascender, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_descender(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    err = js_create_double(env, font.descender, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_cap_height(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    err = js_create_double(env, font.capHeight, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_x_height(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    err = js_create_double(env, font.xHeight, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_leading(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    err = js_create_double(env, font.leading, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_line_height(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    err = js_create_double(env, font.lineHeight, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_font_descriptor(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 {
+    UIFont *font = (__bridge UIFont *) handle;
+
+    result = bare_foundation_bridge(env, state->registry, font.fontDescriptor);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_font_with_descriptor(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 size;
+  if (!bare_ui_kit__read_double(env, argv[1], "size", &size)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    UIFontDescriptor *descriptor = (__bridge UIFontDescriptor *) handle;
+
+    result = bare_foundation_bridge(env, state->registry, [UIFont fontWithDescriptor:descriptor size:size]);
+  }
+
+  return result;
+}