@qxuken/kui 0.1.0-alpha.40 → 0.1.0-alpha.42

package/index.js

@@ -52,8 +52,12 @@ export function withEffects(model, ...effects) {
 
 // A frame crosses the boundary one way: JS encodes the tree into one
 // Float64Array + string table and the addon lowers it zero-copy. One encoder
-// serves every context — its buffers are consumed synchronously.
+// serves every context — its buffers are consumed synchronously. Measuring
+// has one of its own: a `<devtoolsTab>`'s function child is called in the
+// middle of an encode, and a `measureText` there reset the frame's buffers
+// under it ("binary frame must start with the root op").
 const encoder = createEncoder(native.protocol());
+const measurer = createEncoder(native.protocol());
 
 // A prop name the schema does not know has no wire id, so it never crosses:
 // the encoder is the only side that can see it, and it reports what it
@@ -206,7 +210,7 @@ KuiWindow.prototype.setView = function setView(tree, window) {
 // it draws. A style name the schema does not know is reported like a
 // view's would be.
 function measureText(content, style, maxWidth) {
-  const { stream, strings, unknown, unknownTokens } = encoder.encodeText(content, style, this[TOKENS]);
+  const { stream, strings, unknown, unknownTokens } = measurer.encodeText(content, style, this[TOKENS]);
   const m = this.measureTextBinary(stream, strings, maxWidth);
   reportUnknown(this, unknown, unknownTokens);
   return m;

package/jsx-runtime.d.ts

@@ -164,7 +164,9 @@ export interface GradientProp {
   at?: [number, number];
   /** Two or more colours, each alone or as `[colour, position]` with the
    *  position 0 to 1. Stops without one are spaced evenly between those
-   *  with; two at one position are a hard edge. */
+   *  with; two at one position are a hard edge. A `$token` that misses
+   *  is raised as `unknown-token` and its stop left out, so a gradient
+   *  left with fewer than two draws nothing over the `bg`. */
   stops: (ColorProp | [ColorProp, number])[];
 }
 
@@ -301,7 +303,7 @@ export interface GeneratedSpecProps {
   focusable?: boolean;
   /** Space between children along the main axis. */
   gap?: LengthProp;
-  /** A gradient painted over the node's `bg` and under its border and its children (`docs/adr/0042-a-gradient-is-an-image-the-core-paints.md`): `{ to: 'bottom', stops: [...] }` towards a side or a corner (`right`, `bottom left`, …; the default is `bottom`), `{ angle: 0.125, stops }` in turns clockwise from east, or `{ radial: true, at: [0.5, 0], stops }` out from a centre (fractions of the box, the middle by default) to its farthest corner. A stop is a colour — a `$token` too — or `[colour, position]` with the position 0 to 1; stops without one are spaced evenly between those with. Two stops at one position are a hard edge. The gradient is defined on the box's unit square and stretched to it, so a side or a corner is CSS's and any other `angle` runs corner to corner at an eighth of a turn whatever the box's aspect, where CSS's pixel-measured `45deg` does not. Stops mix in straight sRGB with the alpha premultiplied, as CSS's do. What it costs is one image quad: the core rasterizes each distinct gradient once into the glyph atlas — a 256-texel strip along an axis, a 128-texel square otherwise, within half an 8-bit level of the gradient computed per pixel for a linear one and 1.2 for a radial — keyed by the gradient and not the box, so a box that resizes and a thousand boxes that share one rasterize nothing, and a host that draws an image draws it; a gradient box costs about 55 ns over a flat one, so ten thousand of them are half a millisecond. A hard edge is as soft as the raster stretched to the box (a 256th of its length along a strip); stripes are boxes. It does not tween — `transition` eases the `bg` under it and `opacity` fades it — and `hoverBg` and the other state backgrounds replace `bg`, not the gradient; one that changes every frame is a raster a frame, and a shimmer is a `fragment`'s. Ignored on a `line`, a `polygon` and a `path`. Fewer than two stops are an error in JSX and Lua, as a malformed `keyframes` is, and draw nothing in Rust and C. */
+  /** A gradient painted over the node's `bg` and under its border and its children (`docs/adr/0042-a-gradient-is-an-image-the-core-paints.md`): `{ to: 'bottom', stops: [...] }` towards a side or a corner (`right`, `bottom left`, …; the default is `bottom`), `{ angle: 0.125, stops }` in turns clockwise from east, or `{ radial: true, at: [0.5, 0], stops }` out from a centre (fractions of the box, the middle by default) to its farthest corner. A stop is a colour — a `$token` too — or `[colour, position]` with the position 0 to 1; stops without one are spaced evenly between those with. Two stops at one position are a hard edge. The gradient is defined on the box's unit square and stretched to it, so a side or a corner is CSS's and any other `angle` runs corner to corner at an eighth of a turn whatever the box's aspect, where CSS's pixel-measured `45deg` does not. Stops mix in straight sRGB with the alpha premultiplied, as CSS's do. What it costs is one image quad: the core rasterizes each distinct gradient once into the glyph atlas — a 256-texel strip along an axis, a 128-texel square otherwise, within half an 8-bit level of the gradient computed per pixel for a linear one and 1.2 for a radial — keyed by the gradient and not the box, so a box that resizes and a thousand boxes that share one rasterize nothing, and a host that draws an image draws it; a gradient box costs about 55 ns over a flat one, so ten thousand of them are half a millisecond. A hard edge is as soft as the raster stretched to the box (a 256th of its length along a strip); stripes are boxes. It does not tween — `transition` eases the `bg` under it and `opacity` fades it — and `hoverBg` and the other state backgrounds replace `bg`, not the gradient; one that changes every frame is a raster a frame, and a shimmer is a `fragment`'s. Ignored on a `line`, a `polygon` and a `path`. Fewer than two stops are an error in JSX and Lua, as a malformed `keyframes` is, and draw nothing in Rust and C. A stop whose `$token` misses is not an error: it is raised as `unknown-token` and left out, as a miss leaves any slot unset, and the rest are spaced as if it had not been declared — so a gradient left with fewer than two stops, a two-stop one with a typo, draws nothing over its `bg` (backlog RG118). */
   gradient?: GradientProp;
   /** Vertical size: px | "fit" | "grow" | "N%" | a size expression (see `width`). */
   height?: SizingProp;
@@ -500,8 +502,10 @@ export interface CustomSpecProps {
    *  once, so a later Tab press is not clobbered. `ctx.focus(key)` moves
    *  focus at any time. */
   keyFocus?: boolean;
-  /** Hover hint: a tooltip floated below this box while it is hovered
-   *  (implies hoverable). */
+  /** Hover hint: a tooltip floated below this node while it is hovered
+   *  (implies hoverable) — as a box's last child, and beside a leaf that
+   *  holds no children (`line`, `polygon`, `path`, `cells`, `image`,
+   *  `edit`), anchored to it, below its box (backlog RG113). */
   tooltip?: string;
   /** Stable identity by *data* index rather than by name: the key
    *  auto-keying would have given this node as the `i`th child, given to
@@ -546,6 +550,14 @@ export interface BoxProps extends Keyed, GeneratedSpecProps, CustomSpecProps {
    *  Declare it every frame; the frame that stops gives the Option keys
    *  back to the layout. Nothing elsewhere. */
   optionAsAlt?: 'none' | 'left' | 'right' | 'both';
+  /** Root box only: this window takes the keyboard as keys, with the
+   *  platform's input method off (backlog F125) — no composition, and on
+   *  a Mac no dead keys and no press-and-hold, so a held letter repeats
+   *  instead of opening the accent picker. A key's `text` is still the
+   *  layout's character. A modal editor's normal mode: declare it every
+   *  frame the mode wants it; the frame that stops gives the IME, dead
+   *  keys and accents back. */
+  imeOff?: boolean;
   /** Root box only: which windows exist besides the main one (see
    *  `WindowDecl` in `@qxuken/kui`). `runWindowed` / `createApp` write it
    *  from the loop config's `windows(model)`; a view driving a `Ctx` by
@@ -846,9 +858,11 @@ export declare namespace JSX {
          *  gap]` for a dash-dot, in px **as seen** — every mark is
          *  round-capped, so a mark no longer than the stroke is wide is a
          *  dot (SVG's `stroke-dasharray` measures the centre line; this is
-         *  its `mark − width, gap + width`). The pattern runs along the
-         *  whole stroke, corners and curves included. A pattern with no
-         *  gap, or finer than a pixel, draws solid. */
+         *  its `mark − width, gap + width`). A gap the dots overlap — a
+         *  mark and its gap together no longer than the width — closes,
+         *  and the marks either side of it are one. The pattern runs along
+         *  the whole stroke, corners and curves included. A pattern with
+         *  no gap left, or finer than a pixel, draws solid. */
         dash?: number | [number] | [number, number] | [number, number, number, number];
         /** How far into the pattern the stroke starts, in px: growing it
          *  moves the marks towards the first point — a marquee's marching
@@ -938,9 +952,11 @@ export declare namespace JSX {
          *  gap]` for a dash-dot, in px **as seen** — every mark is
          *  round-capped, so a mark no longer than the stroke is wide is a
          *  dot (SVG's `stroke-dasharray` measures the centre line; this is
-         *  its `mark − width, gap + width`). The pattern runs along the
-         *  outline, restarting at every subpath as SVG's does. A pattern with no
-         *  gap, or finer than a pixel, draws solid. */
+         *  its `mark − width, gap + width`). A gap the dots overlap — a
+         *  mark and its gap together no longer than the width — closes,
+         *  and the marks either side of it are one. The pattern runs along
+         *  the outline, restarting at every subpath as SVG's does. A
+         *  pattern with no gap left, or finer than a pixel, draws solid. */
         dash?: number | [number] | [number, number] | [number, number, number, number];
         /** How far into the pattern the stroke starts, in px: growing it
          *  moves the marks towards the first point — a marquee's marching

package/native.cjs

@@ -107,10 +107,17 @@ if (native) {
       'KUI_NODE_LIB at a working library.',
   );
 } else {
+  // An Intel Mac had a prebuild until alpha.40 (as did an x64 Node under
+  // Rosetta on Apple silicon, which reads as the same platform), so it is
+  // told that, not left to guess whether the install went wrong.
+  const dropped =
+    process.platform === 'darwin' && process.arch === 'x64'
+      ? ' (Intel Macs, and an x64 Node under Rosetta, had one until 0.1.0-alpha.40 and build it from source since)'
+      : '';
   throw new Error(
-    `kui native library not found for ${process.platform}-${process.arch} - ` +
-      'this package ships prebuilds for linux-x64, linux-arm64, darwin-arm64, ' +
-      'darwin-x64 and win32-x64; elsewhere run `cargo build -p kui-node --release` in the kui ' +
+    `kui native library not found for ${process.platform}-${process.arch}${dropped} - ` +
+      'this package ships prebuilds for linux-x64, linux-arm64, darwin-arm64 ' +
+      'and win32-x64; elsewhere run `cargo build -p kui-node --release` in the kui ' +
       'repo or point KUI_NODE_LIB at a built library.\nLooked in:\n  ' +
       looked.join('\n  '),
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qxuken/kui",
-  "version": "0.1.0-alpha.40",
+  "version": "0.1.0-alpha.42",
   "description": "kui for Node: JSX views lowered into the kui IR, Elm-style messages as data",
   "license": "MIT",
   "repository": {