ntk 2.1.1 → 3.0.0

package/lib/fontconfig.js

@@ -1,15 +1,123 @@
-module.exports.listFontsSync = function(pattern) {
-  var fmPattern = {};
-  fmPattern.family = pattern.family;
-  if (pattern.style.indexOf('italic') != -1)
-    fmPattern.italic = true;
-  if (pattern.weight == 'normal')
-    fmPattern.weight = 400;
-  else if (pattern.weight == 'bold')
-    fmPattern.weight = 700;
-  else if (!isNaN(parseInt(pattern.weight)))
-    fmPattern.weight = parseInt(pattern.weight);
-
-  var match = require('font-manager').findFontSync(fmPattern);
-  return match;
+// node:child_process is fetched lazily (not via static import) so that
+// browser bundles of the package never try to resolve it; in non-node
+// environments use a custom FontSource instead (see text/fontsource.js).
+function execFileSync(...args) {
+  const cp = globalThis.process?.getBuiltinModule?.('node:child_process');
+  if (!cp) {
+    throw new Error(
+      'fontconfig matching needs node (fc-match CLI); in this environment pass a custom fontSource — see docs/fonts.md'
+    );
+  }
+  return cp.execFileSync(...args);
+}
+
+// css weight -> fontconfig weight constants
+const cssToFcWeight = {
+  100: 0, // thin
+  200: 40, // extralight
+  300: 50, // light
+  400: 80, // regular
+  500: 100, // medium
+  600: 180, // demibold
+  700: 200, // bold
+  800: 205, // extrabold
+  900: 210 // black
 };
+
+// formats fontkit can parse
+const supported = /\.(ttf|otf|woff|woff2|ttc|dfont)$/i;
+
+const sortedCache = new Map();
+
+function patternFor({ family, weight, style }) {
+  let fc = family || 'sans-serif';
+  const fcWeight = normalizeWeight(weight);
+  if (fcWeight !== undefined) fc += `:weight=${fcWeight}`;
+  if (style && style.includes('italic')) fc += ':slant=italic';
+  return fc;
+}
+
+/**
+ * Full fontconfig match list for a pattern, best match first — this is the
+ * system's font fallback chain. Each candidate carries the unicode coverage
+ * fontconfig knows about (`charset`, lazily parsed via `charsetHas`), so a
+ * fallback font for a codepoint can be chosen without opening font files.
+ *
+ * Cached per pattern; one fc-match invocation (~50ms) per distinct pattern.
+ *
+ * @returns {Array<{path, postscriptName, charset: string}>}
+ */
+export function matchSortedSync(pattern) {
+  const fc = patternFor(pattern);
+  let list = sortedCache.get(fc);
+  if (list) return list;
+
+  const out = execFileSync(
+    'fc-match',
+    ['-s', '--format', '%{file}\t%{postscriptname}\t%{charset}\n', fc],
+    { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }
+  );
+  list = [];
+  for (const line of out.split('\n')) {
+    const [path, postscriptName, charset] = line.split('\t');
+    if (path && supported.test(path)) {
+      list.push({ path, postscriptName, charset: charset || '', _ranges: null });
+    }
+  }
+  if (list.length === 0) {
+    throw new Error(`No usable font found for pattern "${fc}" (need .ttf/.otf/.ttc)`);
+  }
+  sortedCache.set(fc, list);
+  return list;
+}
+
+/**
+ * Resolve a font pattern ({family, weight, style}) to the best matching font
+ * file. Returns { path, postscriptName } or throws if nothing suitable is
+ * installed. Requires the fc-match CLI (fontconfig), present on any system
+ * running X11.
+ */
+export function listFontsSync(pattern) {
+  const [best] = matchSortedSync(pattern);
+  return { path: best.path, postscriptName: best.postscriptName };
+}
+
+/**
+ * Does a fc-match candidate's charset cover a codepoint?
+ * The charset string is fontconfig's range format: "20-7e a0-ff 131 ...".
+ */
+export function charsetHas(candidate, codepoint) {
+  if (candidate._ranges === null) {
+    const ranges = [];
+    for (const part of candidate.charset.split(' ')) {
+      if (!part) continue;
+      const dash = part.indexOf('-');
+      if (dash === -1) {
+        const v = parseInt(part, 16);
+        ranges.push(v, v);
+      } else {
+        ranges.push(parseInt(part.slice(0, dash), 16), parseInt(part.slice(dash + 1), 16));
+      }
+    }
+    candidate._ranges = ranges;
+  }
+  const r = candidate._ranges;
+  let lo = 0;
+  let hi = r.length / 2 - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (codepoint < r[mid * 2]) hi = mid - 1;
+    else if (codepoint > r[mid * 2 + 1]) lo = mid + 1;
+    else return true;
+  }
+  return false;
+}
+
+function normalizeWeight(weight) {
+  if (weight === undefined) return undefined;
+  if (weight === 'normal') return cssToFcWeight[400];
+  if (weight === 'bold') return cssToFcWeight[700];
+  const n = parseInt(weight, 10);
+  if (Number.isNaN(n)) return undefined;
+  return cssToFcWeight[n] !== undefined ? cssToFcWeight[n] : n;
+}

package/lib/glyphset.js

@@ -1,22 +1,40 @@
-var weak = require('weak');
+import { safeRelease } from './cleanup.js';
 
-function GlyphSet(app, args)
-{
-  var X = app.X;
-  this.X = X;
-  var display = app.display;
-  this.Render = display.Render;
-  this.display = display;
-  this.id = X.AllocID();
-  this.Render.CreateGlyphSet(this.id, this.Render.a8);
-  var ref = weak(this, function (obj) {
-    X.FreeGlyphSet(obj.id);
+const registry = new FinalizationRegistry(({ Render, X, id }) => {
+  safeRelease(X, () => {
+    Render.FreeGlyphSet(id);
+    X.ReleaseID(id);
   });
-}
+});
+
+export default class GlyphSet {
+  constructor(app, format) {
+    const X = app.X;
+    this.X = X;
+    this.display = app.display;
+    this.Render = app.display.Render;
+    this.id = X.AllocID();
+    this.Render.CreateGlyphSet(this.id, format || this.Render.a8);
+    this._owned = true;
+    registry.register(this, { Render: this.Render, X, id: this.id }, this);
+  }
 
-GlyphSet.prototype.addGlyphs = function(glyphs) {
-  this.Render.AddGlyphs(this.id, glyphs);
-  this._glyphs = glyphs;
-};
+  addGlyphs(glyphs) {
+    if (glyphs.length === 0) return;
+    this.Render.AddGlyphs(this.id, glyphs);
+  }
 
-module.exports = GlyphSet;
+  destroy() {
+    if (!this._owned) return;
+    this._owned = false;
+    registry.unregister(this);
+    safeRelease(this.X, () => {
+      this.Render.FreeGlyphSet(this.id);
+      this.X.ReleaseID(this.id);
+    });
+  }
+
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+}

package/lib/image.js

@@ -0,0 +1,138 @@
+import jpeg from 'jpeg-js';
+import { PNG } from 'pngjs';
+
+import Picture from './picture.js';
+
+/**
+ * A decoded raster image: `width`, `height` and non-premultiplied RGBA
+ * pixels in `data`. Images are client-side objects independent of any X
+ * connection; the first time one is drawn it is uploaded to that server
+ * as a 32-bit pixmap and cached, so repeated draws are a single
+ * server-side composite.
+ *
+ * Create with `loadImage(pathOrBuffer)` / `decodeImage(buffer)`, or from
+ * raw pixels: `new Image({ width, height, data })`.
+ */
+export class Image {
+  constructor({ width, height, data }) {
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+      throw new Error('Image: width and height must be positive integers');
+    }
+    if (!data || data.length !== width * height * 4) {
+      throw new Error(`Image: data must be RGBA, ${width * height * 4} bytes`);
+    }
+    this.width = width;
+    this.height = height;
+    this.data = data;
+    this._uploads = new Map(); // App -> { pixmap, picture }
+  }
+
+  /**
+   * The server-side Picture for this image on `app`'s display (uploaded
+   * and cached on first use). Used by `ctx.drawImage`; useful directly
+   * when compositing manually via the Render extension.
+   */
+  picture(app) {
+    let upload = this._uploads.get(app);
+    if (upload) return upload.picture;
+
+    const X = app.X;
+    const Render = app.display.Render;
+    const pixmap = app.createPixmap({ depth: 32, width: this.width, height: this.height });
+
+    // XRender composites premultiplied alpha; PutImage on a 32-bit ZPixmap
+    // wants BGRA byte order (see AGENTS.md gotchas)
+    const bgra = Buffer.allocUnsafe(this.width * this.height * 4);
+    const src = this.data;
+    for (let i = 0; i < bgra.length; i += 4) {
+      const a = src[i + 3];
+      if (a === 255) {
+        bgra[i] = src[i + 2];
+        bgra[i + 1] = src[i + 1];
+        bgra[i + 2] = src[i];
+      } else {
+        bgra[i] = (src[i + 2] * a + 127) / 255;
+        bgra[i + 1] = (src[i + 1] * a + 127) / 255;
+        bgra[i + 2] = (src[i] * a + 127) / 255;
+      }
+      bgra[i + 3] = a;
+    }
+
+    // node-x11 has no FreeGC — share one upload GC per app (valid for any
+    // depth-32 drawable on the screen)
+    let gc = app._imageUploadGC;
+    if (!gc) {
+      gc = app._imageUploadGC = X.AllocID();
+      X.CreateGC(gc, pixmap.id);
+    }
+    // stay under the server's maximum request size by uploading row bands
+    const stride = this.width * 4;
+    const maxBytes = ((app.display.max_request_length ?? 65535) - 8) * 4;
+    const rowsPerBand = Math.max(1, Math.floor(maxBytes / stride));
+    for (let y = 0; y < this.height; y += rowsPerBand) {
+      const rows = Math.min(rowsPerBand, this.height - y);
+      X.PutImage(2, pixmap.id, gc, this.width, rows, 0, y, 0, 32, bgra.subarray(y * stride, (y + rows) * stride));
+    }
+
+    const picture = new Picture(app, { drawable: pixmap, format: Render.rgba32 });
+    upload = { pixmap, picture };
+    this._uploads.set(app, upload);
+    return picture;
+  }
+
+  /** free server-side copies of this image (safe to draw again afterwards) */
+  destroy() {
+    for (const { pixmap, picture } of this._uploads.values()) {
+      picture.destroy();
+      pixmap.destroy();
+    }
+    this._uploads.clear();
+  }
+
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+}
+
+const PNG_MAGIC = [0x89, 0x50, 0x4e, 0x47];
+
+/**
+ * Decode a PNG or JPEG buffer (sniffed by magic bytes) into an Image.
+ *
+ * @param {Buffer|Uint8Array} buffer encoded image bytes
+ * @returns {Image}
+ */
+export function decodeImage(buffer) {
+  const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+  if (buf.length > 4 && PNG_MAGIC.every((b, i) => buf[i] === b)) {
+    const png = PNG.sync.read(buf);
+    return new Image({ width: png.width, height: png.height, data: png.data });
+  }
+  if (buf.length > 2 && buf[0] === 0xff && buf[1] === 0xd8) {
+    const img = jpeg.decode(buf, { useTArray: true, maxMemoryUsageInMB: 512 });
+    return new Image({ width: img.width, height: img.height, data: Buffer.from(img.data) });
+  }
+  throw new Error('decodeImage: unsupported image format (PNG and JPEG are supported)');
+}
+
+/**
+ * Load and decode a PNG or JPEG image.
+ *
+ *   const img = await loadImage('logo.png');
+ *   ctx.drawImage(img, 10, 10);
+ *
+ * @param {string|URL|Buffer|Uint8Array} source file path (or file URL), or
+ *   an in-memory buffer of encoded bytes
+ * @returns {Promise<Image>}
+ */
+export async function loadImage(source) {
+  if (typeof source === 'string' || source instanceof URL) {
+    // lazy builtin lookup: browser bundles must not depend on node:fs
+    const fsp = globalThis.process?.getBuiltinModule?.('node:fs/promises');
+    if (!fsp) {
+      throw new Error('loadImage: file paths need node — pass the encoded bytes instead');
+    }
+    return decodeImage(await fsp.readFile(source));
+  }
+  return decodeImage(source);
+}

package/lib/index.js

@@ -1,65 +1,123 @@
-var Promise = require('es6-promise').Promise;
-var x11 = require('x11');
-var App = require('./app');
+import x11 from 'x11';
 
+import App from './app.js';
+import Window from './window.js';
+import Pixmap from './pixmap.js';
+import Picture from './picture.js';
+import { Image, decodeImage, loadImage } from './image.js';
+import { Path2D, parseSvgPath } from './path.js';
+import Font from './text/font.js';
+import FontManager from './text/fontmanager.js';
+import {
+  FontconfigFontSource,
+  StaticFontSource,
+  defaultFontSource,
+  setDefaultFontSource
+} from './text/fontsource.js';
+import { TextLayout } from './text/layout.js';
+import HtmlView from './widgets/htmlview.js';
+import SvgView from './widgets/svgview.js';
+import MarkdownView from './widgets/markdownview.js';
+import TexView, { configureTex, layoutTex, TexBox } from './widgets/tex.js';
+import { tokenize as highlightCode } from './widgets/highlight.js';
 
-module.exports.createClient = function(main) {
-  return new Promise(function(resolve, reject) {
+// rendering context modules register themselves on Drawable
+import './renderingcontext_x11.js';
+import './renderingcontext_2d.js';
+import './renderingcontext_opengl.js';
 
-     var callback = function(err, display) {
-       if (err) {
-         reject(err);
-         if (main)
-           return main(err);
-       }
-       resolve(display);
-       if (main)
-         return main(null, display);
-     }
+/**
+ * Connect to the X server and resolve with an App.
+ *
+ *   const app = await createClient();
+ *
+ * The legacy node-style callback is still supported:
+ *
+ *   createClient((err, app) => { ... });
+ *
+ * @param {object} [options] passed through to x11.createClient
+ *   (e.g. { display: ':1' }); ntk additionally understands
+ *   { fontSource } — a pluggable system-font lookup (see docs/fonts.md) —
+ *   and { glxVisual } — the visual id for getContext('opengl') in
+ *   environments where `glxinfo` cannot be shelled out to
+ * @param {function} [callback] optional node-style callback
+ * @returns {Promise<App>}
+ */
+export function createClient(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
 
-     x11.createClient({ debug: true }, function(error, display) {
-        if (error)
-          return callback(error, null);
+  const promise = new Promise((resolve, reject) => {
+    x11.createClient(options || {}, (error, display) => {
+      if (error) return reject(error);
 
-        display.client.on('error', function(err) {
-          console.log(err.longstack);
-          process.exit(1);
-        });
-
-        display.client.require('glx', function(err, GLX) {
-          display.client.require('render', function(err, Render) {
-            // we prelod Render and GLX
-            display.Render = Render;
-            display.GLX = GLX;
-            var X = display.client;
-            X.keycode2keysyms = {}
-
-            function updateKeyboardMapping(min, max) {
-              if (max <= min)
-                return;
-
-              X.GetKeyboardMapping(min, max-min, function(err, list) {
-                for (var i=0; i < list.length; ++i)
-                  X.keycode2keysyms[i+min] = list[i].slice();
-              });
-            }
+      display.client.require('glx', (glxError, GLX) => {
+        display.client.require('render', (renderError, Render) => {
+          if (renderError) return reject(renderError);
+          // preload Render and GLX; GLX is optional ( indirect GLX is often
+          // disabled on modern servers )
+          display.Render = Render;
+          display.GLX = glxError ? null : GLX;
+          const X = display.client;
+          X.keycode2keysyms = {};
 
-            X.on('event', function(ev) {
-              // MappingNotify
-              if (ev.type == 34) {
-                updateKeyboardMapping(ev.firstKeyCode, ev.firstKeyCode + ev.count);
-              }
+          function updateKeyboardMapping(min, max) {
+            if (max <= min) return;
+            X.GetKeyboardMapping(min, max - min, (err, list) => {
+              if (err) return;
+              for (let i = 0; i < list.length; ++i) X.keycode2keysyms[i + min] = list[i].slice();
             });
-            updateKeyboardMapping(display.min_keycode, display.max_keycode);
+          }
 
-            var app = new App(display);
-            callback(null, app);
+          X.on('event', (ev) => {
+            // MappingNotify
+            if (ev.type === 34) {
+              updateKeyboardMapping(ev.firstKeyCode, ev.firstKeyCode + ev.count);
+            }
           });
+          updateKeyboardMapping(display.min_keycode, display.max_keycode);
+
+          resolve(new App(display, options || {}));
         });
+      });
     });
   });
-};
 
-require('./renderingcontext_x11');
-require('./renderingcontext_2d');
-require('./renderingcontext_opengl');
+  if (callback) {
+    promise.then(
+      (app) => callback(null, app),
+      (err) => callback(err)
+    );
+  }
+  return promise;
+}
+
+export {
+  App,
+  Window,
+  Pixmap,
+  Picture,
+  Image,
+  decodeImage,
+  loadImage,
+  Path2D,
+  parseSvgPath,
+  Font,
+  FontManager,
+  FontconfigFontSource,
+  StaticFontSource,
+  defaultFontSource,
+  setDefaultFontSource,
+  TextLayout,
+  HtmlView,
+  SvgView,
+  MarkdownView,
+  TexView,
+  TexBox,
+  layoutTex,
+  configureTex,
+  highlightCode
+};
+export default { createClient };