bare-ui-kit 0.2.0 → 0.3.0

package/lib/attributed-string.d.ts

@@ -0,0 +1,45 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+import UIKitColor = require('./color')
+import UIKitFont = require('./font')
+import UIKitParagraphStyle = require('./paragraph-style')
+
+/** Text with styles, as an `NSMutableAttributedString`. */
+interface UIKitAttributedString {
+  readonly string: string
+
+  readonly length: number
+
+  /** The styles of the character at `location`. */
+  attributesAt(location: number): UIKitAttributedString.Attributes
+
+  /** Add another attributed string at the end. It can come from another addon. */
+  append(other: Wrapper): this
+
+  /** Add `string` at the end, with `attributes`. */
+  appendString(string: string, attributes?: UIKitAttributedString.Attributes): this
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitAttributedString {
+  constructor(opts?: { string?: string; attributes?: UIKitAttributedString.Attributes })
+}
+
+declare namespace UIKitAttributedString {
+  export interface Attributes {
+    font?: UIKitFont | null
+    foregroundColor?: UIKitColor | null
+    backgroundColor?: UIKitColor | null
+    paragraphStyle?: UIKitParagraphStyle | null
+
+    /** Extra space between characters, in points. */
+    kern?: number
+    baselineOffset?: number
+    underlineStyle?: number
+    strikethroughStyle?: number
+  }
+}
+
+export = UIKitAttributedString

package/lib/attributed-string.h

@@ -0,0 +1,176 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_attributed_string_init(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);
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    NSString *string = bare_ui_kit__to_string(env, argv[0]);
+
+    NSDictionary<NSAttributedStringKey, id> *attributes = bare_ui_kit__to_attributes(env, state, argv[1]);
+
+    NSMutableAttributedString *handle = [[[NSMutableAttributedString alloc]
+      initWithString:string ? string : @"" attributes:attributes] autorelease];
+
+    result = bare_foundation_bridge(env, state->registry, handle);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_attributed_string_string(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 {
+    NSAttributedString *string = (__bridge NSAttributedString *) handle;
+
+    result = bare_ui_kit__from_string(env, string.string);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_attributed_string_length(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 {
+    NSAttributedString *string = (__bridge NSAttributedString *) handle;
+
+    err = js_create_uint32(env, (uint32_t) string.length, &result);
+    assert(err == 0);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_attributed_string_attributes_at(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 location;
+  if (!bare_ui_kit__read_uint32(env, argv[1], "location", &location)) return NULL;
+
+  js_value_t *result;
+
+  @autoreleasepool {
+    NSAttributedString *string = (__bridge NSAttributedString *) handle;
+
+    result = bare_ui_kit__from_attributes(env, state, [string attributesAtIndex:location effectiveRange:NULL]);
+  }
+
+  return result;
+}
+
+static js_value_t *
+bare_ui_kit_attributed_string_append(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;
+
+  @autoreleasepool {
+    NSMutableAttributedString *string = (__bridge NSMutableAttributedString *) handle;
+
+    [string appendAttributedString:bare_foundation_to_object(env, state->registry, argv[1])];
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ui_kit_attributed_string_append_string(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;
+
+  @autoreleasepool {
+    NSMutableAttributedString *string = (__bridge NSMutableAttributedString *) handle;
+
+    NSString *appended = bare_ui_kit__to_string(env, argv[1]);
+
+    NSDictionary<NSAttributedStringKey, id> *attributes = bare_ui_kit__to_attributes(env, state, argv[2]);
+
+    [string appendAttributedString:[[[NSAttributedString alloc]
+      initWithString:appended ? appended : @"" attributes:attributes] autorelease]];
+  }
+
+  return NULL;
+}

package/lib/attributed-string.js

@@ -0,0 +1,51 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+const { adopt } = require('./handle')
+const { wrapAttributes, unwrapAttributes } = require('./attributes')
+
+module.exports = exports = class UIKitAttributedString {
+  constructor(opts = {}) {
+    const { tag = null, string = '', attributes = {} } = opts
+
+    this._tag =
+      tag === null ? binding.attributedStringInit(string, unwrapAttributes(attributes)) : tag
+
+    this._token = binding.claim(this._tag, this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  get string() {
+    return binding.attributedStringString(this._tag)
+  }
+
+  get length() {
+    return binding.attributedStringLength(this._tag)
+  }
+
+  attributesAt(location) {
+    return wrapAttributes(binding.attributedStringAttributesAt(this._tag, location))
+  }
+
+  append(other) {
+    binding.attributedStringAppend(this._tag, adopt(other))
+    return this
+  }
+
+  appendString(string, attributes = {}) {
+    binding.attributedStringAppendString(this._tag, string, unwrapAttributes(attributes))
+    return this
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitAttributedString }
+    }
+  }
+}

package/lib/attributes.js

@@ -0,0 +1,34 @@
+const UIKitColor = require('./color')
+const UIKitFont = require('./font')
+const UIKitParagraphStyle = require('./paragraph-style')
+const wrap = require('./wrap')
+
+// Attributes hold wrappers in JavaScript and tags in native code.
+const WRAPPERS = {
+  font: UIKitFont,
+  foregroundColor: UIKitColor,
+  backgroundColor: UIKitColor,
+  paragraphStyle: UIKitParagraphStyle
+}
+
+exports.unwrapAttributes = function unwrapAttributes(attributes) {
+  const result = {}
+
+  for (const [key, value] of Object.entries(attributes)) {
+    result[key] = key in WRAPPERS && value !== null ? value._tag : value
+  }
+
+  return result
+}
+
+exports.wrapAttributes = function wrapAttributes(attributes) {
+  const result = {}
+
+  for (const [key, value] of Object.entries(attributes)) {
+    const Wrapper = WRAPPERS[key]
+
+    result[key] = Wrapper ? wrap(Wrapper, value) : value
+  }
+
+  return result
+}

package/lib/bezier-path.d.ts

@@ -0,0 +1,26 @@
+import { tag, handle, Handle, Wrapper } from 'bare-foundation-registry'
+
+/** A path made of lines and curves, as a `UIBezierPath`. */
+interface UIKitBezierPath {
+  moveTo(x: number, y: number): this
+
+  lineTo(x: number, y: number): this
+
+  /** Add a curve to `x`, `y`, with the control points `x1`, `y1` and `x2`, `y2`. */
+  curveTo(x: number, y: number, x1: number, y1: number, x2: number, y2: number): this
+
+  /** Add an arc around `x`, `y`. The angles are in radians. */
+  addArc(x: number, y: number, radius: number, startAngle: number, endAngle: number): this
+
+  closePath(): this
+
+  readonly [tag]: number
+
+  readonly [handle]: Handle
+}
+
+declare class UIKitBezierPath {
+  constructor()
+}
+
+export = UIKitBezierPath

package/lib/bezier-path.h

@@ -0,0 +1,145 @@
+#import <assert.h>
+#import <bare.h>
+#import <js.h>
+
+#import <UIKit/UIKit.h>
+
+#import "bridging.h"
+
+static js_value_t *
+bare_ui_kit_bezier_path_init(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, [UIBezierPath bezierPath]);
+  }
+
+  return result;
+}
+
+#define V(name, expr) \
+  static js_value_t * \
+  bare_ui_kit_bezier_path_##name(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; \
+    double x, y; \
+    err = js_get_value_double(env, argv[1], &x); \
+    assert(err == 0); \
+    err = js_get_value_double(env, argv[2], &y); \
+    assert(err == 0); \
+    @autoreleasepool { \
+      UIBezierPath *path = (__bridge UIBezierPath *) handle; \
+      [path expr:CGPointMake(x, y)]; \
+    } \
+    return NULL; \
+  }
+
+V(move_to, moveToPoint)
+V(line_to, addLineToPoint)
+#undef V
+
+static js_value_t *
+bare_ui_kit_bezier_path_curve_to(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 7;
+  js_value_t *argv[7];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 7);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  double values[6];
+
+  for (int i = 0; i < 6; i++) {
+    err = js_get_value_double(env, argv[i + 1], &values[i]);
+    assert(err == 0);
+  }
+
+  @autoreleasepool {
+    UIBezierPath *path = (__bridge UIBezierPath *) handle;
+
+    [path addCurveToPoint:CGPointMake(values[0], values[1])
+            controlPoint1:CGPointMake(values[2], values[3])
+            controlPoint2:CGPointMake(values[4], values[5])];
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ui_kit_bezier_path_add_arc(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 6;
+  js_value_t *argv[6];
+
+  bare_ui_kit_state_t *state;
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &state);
+  assert(err == 0);
+
+  assert(argc == 6);
+
+  void *handle;
+  if (bare_foundation_read_tag(env, state->registry, argv[0], "handle", &handle) < 0) return NULL;
+
+  double values[5];
+
+  for (int i = 0; i < 5; i++) {
+    err = js_get_value_double(env, argv[i + 1], &values[i]);
+    assert(err == 0);
+  }
+
+  @autoreleasepool {
+    UIBezierPath *path = (__bridge UIBezierPath *) handle;
+
+    [path addArcWithCenter:CGPointMake(values[0], values[1])
+                    radius:values[2]
+                startAngle:values[3]
+                  endAngle:values[4]
+                 clockwise:YES];
+  }
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ui_kit_bezier_path_close(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;
+
+  @autoreleasepool {
+    [(__bridge UIBezierPath *) handle closePath];
+  }
+
+  return NULL;
+}

package/lib/bezier-path.js

@@ -0,0 +1,51 @@
+const binding = require('../binding')
+const registry = require('bare-foundation-registry')
+
+module.exports = exports = class UIKitBezierPath {
+  constructor(opts = {}) {
+    const { tag = null } = opts
+
+    this._tag = tag === null ? binding.bezierPathInit() : tag
+
+    this._token = binding.claim(this._tag, this)
+  }
+
+  get [registry.tag]() {
+    return this._tag
+  }
+
+  get [registry.handle]() {
+    return binding.handle(this._tag)
+  }
+
+  moveTo(x, y) {
+    binding.bezierPathMoveTo(this._tag, x, y)
+    return this
+  }
+
+  lineTo(x, y) {
+    binding.bezierPathLineTo(this._tag, x, y)
+    return this
+  }
+
+  curveTo(x, y, x1, y1, x2, y2) {
+    binding.bezierPathCurveTo(this._tag, x, y, x1, y1, x2, y2)
+    return this
+  }
+
+  addArc(x, y, radius, startAngle, endAngle) {
+    binding.bezierPathAddArc(this._tag, x, y, radius, startAngle, endAngle)
+    return this
+  }
+
+  closePath() {
+    binding.bezierPathClose(this._tag)
+    return this
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: UIKitBezierPath }
+    }
+  }
+}