herdr-remote 0.2.39 → 0.3.32

package/dist/terminal-font/formats.js

@@ -1,355 +0,0 @@
-// The formats terminal settings come in: INI, GVariant, Pango and Qt font
-// strings, fontconfig patterns, JSONC, a TOML subset and X resources.
-import { pointsToPx, positiveNumber } from './deps.js';
-/** `[section]` / `key=value` files: konsolerc, kdeglobals, terminalrc, foot.ini. */
-export function parseIni(text) {
-    const sections = { '': {} };
-    let current = sections[''];
-    for (const rawLine of String(text || '').split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith('#') || line.startsWith(';'))
-            continue;
-        const header = /^\[(.+)\]$/.exec(line);
-        if (header) {
-            current = sections[header[1].trim()] ||= {};
-            continue;
-        }
-        const equals = line.indexOf('=');
-        if (equals === -1)
-            continue;
-        current[line.slice(0, equals).trim()] = line.slice(equals + 1).trim();
-    }
-    return sections;
-}
-/** A GSettings value as printed by `gsettings get`: `'text'`, `true`, `@as []`. */
-export function parseGVariantString(output) {
-    const text = String(output || '').trim();
-    const quoted = /^'((?:[^'\\]|\\.)*)'$/.exec(text) || /^"((?:[^"\\]|\\.)*)"$/.exec(text);
-    if (!quoted)
-        return null;
-    return quoted[1].replace(/\\(.)/g, '$1');
-}
-const PANGO_STYLE_WORDS = new Set([
-    'normal',
-    'roman',
-    'oblique',
-    'italic',
-    'small-caps',
-    'all-small-caps',
-    'petite-caps',
-    'all-petite-caps',
-    'unicase',
-    'title-caps',
-    'ultra-condensed',
-    'extra-condensed',
-    'condensed',
-    'semi-condensed',
-    'semi-expanded',
-    'expanded',
-    'extra-expanded',
-    'ultra-expanded',
-    'thin',
-    'ultra-light',
-    'extra-light',
-    'light',
-    'semi-light',
-    'demi-light',
-    'book',
-    'regular',
-    'medium',
-    'semi-bold',
-    'demi-bold',
-    'bold',
-    'ultra-bold',
-    'extra-bold',
-    'heavy',
-    'black',
-    'ultra-black',
-    'extra-black',
-    'ultra-heavy',
-    'extra-heavy',
-    'not-rotated',
-    'south',
-    'upside-down',
-    'north',
-    'rotated-left',
-    'east',
-    'rotated-right',
-    'west',
-]);
-/**
- * `JetBrainsMono Nerd Font Bold 9` → family and size.
- *
- * Pango writes `FAMILY-LIST [STYLE-OPTIONS] [SIZE[px]] [@VARIATIONS]`: the
- * size and the style words are peeled off the end, and what is left is the
- * family list, whose first entry is the face the terminal asked for.
- */
-export function parsePangoFontDescription(description) {
-    if (typeof description !== 'string')
-        return null;
-    const words = description.trim().split(/\s+/).filter(Boolean);
-    while (words.length && words[words.length - 1].startsWith('@'))
-        words.pop();
-    let sizePx;
-    const size = /^(\d+(?:\.\d+)?)(px)?$/i.exec(words[words.length - 1] || '');
-    if (size && words.length > 1) {
-        words.pop();
-        sizePx = size[2] ? positiveNumber(size[1]) : pointsToPx(size[1]);
-    }
-    while (words.length > 1) {
-        const last = words[words.length - 1].toLowerCase();
-        if (!PANGO_STYLE_WORDS.has(last) && !/^weight=\d+$/.test(last))
-            break;
-        words.pop();
-    }
-    const family = words.join(' ').split(',')[0].trim();
-    return family ? { family, sizePx } : null;
-}
-/** Qt's `QFont::toString()`: `JetBrains Mono,10,-1,5,400,0,...`. */
-export function parseQtFontString(value) {
-    if (typeof value !== 'string')
-        return null;
-    const parts = value.split(',');
-    const family = (parts[0] || '').trim();
-    if (!family)
-        return null;
-    const points = Number(parts[1]);
-    const pixels = Number(parts[2]);
-    const sizePx = points > 0 ? pointsToPx(points) : pixels > 0 ? pixels : undefined;
-    return { family, sizePx };
-}
-/** A fontconfig pattern as foot writes it: `JetBrains Mono:size=10:weight=bold`. */
-export function parseFontconfigPattern(value) {
-    if (typeof value !== 'string')
-        return null;
-    const first = value.split(/(?<!\\),/)[0];
-    const [rawFamily, ...properties] = first.split(/(?<!\\):/);
-    const family = rawFamily.replace(/\\(.)/g, '$1').trim();
-    if (!family)
-        return null;
-    let sizePx;
-    for (const property of properties) {
-        const [key, raw] = property.split('=');
-        if (key === 'size')
-            sizePx = pointsToPx(raw);
-        else if (key === 'pixelsize')
-            sizePx = positiveNumber(raw);
-    }
-    return { family, sizePx };
-}
-/** The first entry of a CSS font-family list: `'Fira Code', monospace` → `Fira Code`. */
-export function firstCssFamily(value) {
-    if (typeof value !== 'string')
-        return null;
-    const first = value
-        .split(',')[0]
-        .trim()
-        .replace(/^(['"])(.*)\1$/, '$2')
-        .trim();
-    return first || null;
-}
-/** JSON with comments and trailing commas, as VS Code writes its settings. */
-export function parseJsonc(text) {
-    if (typeof text !== 'string')
-        return null;
-    let out = '';
-    let inString = false;
-    for (let i = 0; i < text.length; i += 1) {
-        const char = text[i];
-        if (inString) {
-            out += char;
-            if (char === '\\') {
-                out += text[i + 1] || '';
-                i += 1;
-            }
-            else if (char === '"')
-                inString = false;
-            continue;
-        }
-        if (char === '"') {
-            inString = true;
-            out += char;
-            continue;
-        }
-        if (char === '/' && text[i + 1] === '/') {
-            while (i < text.length && text[i] !== '\n')
-                i += 1;
-            out += '\n';
-            continue;
-        }
-        if (char === '/' && text[i + 1] === '*') {
-            i += 2;
-            while (i < text.length && !(text[i] === '*' && text[i + 1] === '/'))
-                i += 1;
-            i += 1;
-            continue;
-        }
-        out += char;
-    }
-    try {
-        return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1'));
-    }
-    catch {
-        return null;
-    }
-}
-/** `line` up to a `#` that starts a comment, not one inside a string. */
-function withoutTomlComment(line) {
-    let quote = '';
-    for (let i = 0; i < line.length; i += 1) {
-        const char = line[i];
-        if (quote) {
-            if (char === '\\' && quote === '"')
-                i += 1;
-            else if (char === quote)
-                quote = '';
-        }
-        else if (char === '"' || char === "'")
-            quote = char;
-        else if (char === '#')
-            return line.slice(0, i);
-    }
-    return line;
-}
-/**
- * Just enough TOML for Alacritty's font keys and Herdr's `keys.prefix`:
- * tables, dotted keys, strings, numbers, inline tables and (possibly
- * multi-line) string arrays. Returns a flat `dotted.key → value` map.
- */
-export function parseTomlSubset(text) {
-    const values = {};
-    const lines = String(text || '').split(/\r?\n/);
-    let table = '';
-    const unquote = (raw) => {
-        const value = raw.trim();
-        const basic = /^"((?:[^"\\]|\\.)*)"/.exec(value);
-        if (basic)
-            return basic[1].replace(/\\(.)/g, '$1');
-        const literal = /^'([^']*)'/.exec(value);
-        if (literal)
-            return literal[1];
-        const number = Number(value.replace(/#.*$/, '').trim());
-        return Number.isFinite(number) ? number : undefined;
-    };
-    const keyPath = (raw) => raw.split('.').map((part) => part.trim().replace(/^(['"])(.*)\1$/, '$2'));
-    const assign = (prefix, rawKey, rawValue) => {
-        const key = [...(prefix ? [prefix] : []), ...keyPath(rawKey)].join('.');
-        const value = rawValue.trim();
-        if (value.startsWith('{')) {
-            const body = value.slice(1, value.lastIndexOf('}'));
-            for (const pair of body.split(/,(?=(?:[^"']|"[^"]*"|'[^']*')*$)/)) {
-                const equals = pair.indexOf('=');
-                if (equals !== -1)
-                    assign(key, pair.slice(0, equals), pair.slice(equals + 1));
-            }
-            return;
-        }
-        if (value.startsWith('[')) {
-            values[key] = [...value.matchAll(/"((?:[^"\\]|\\.)*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2]);
-            return;
-        }
-        const parsed = unquote(value);
-        if (parsed !== undefined)
-            values[key] = parsed;
-    };
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index].trim();
-        if (!line || line.startsWith('#'))
-            continue;
-        const header = /^\[([^[\]]+)\]/.exec(line);
-        if (header) {
-            table = keyPath(header[1]).join('.');
-            continue;
-        }
-        if (line.startsWith('[[')) {
-            table = '\0';
-            continue;
-        }
-        if (table === '\0')
-            continue;
-        const equals = line.indexOf('=');
-        if (equals === -1)
-            continue;
-        let rawValue = line.slice(equals + 1);
-        if (rawValue.trim().startsWith('[')) {
-            // A comment inside an array may hold quotes or a `]` of its own.
-            rawValue = withoutTomlComment(rawValue);
-            // An array may span lines; gather it before assigning.
-            while (index + 1 < lines.length && !rawValue.includes(']')) {
-                index += 1;
-                rawValue += ` ${withoutTomlComment(lines[index]).trim()}`;
-            }
-        }
-        assign(table, line.slice(0, equals), rawValue);
-    }
-    return values;
-}
-/** The last value given to any of `names` on a command line. */
-export function optionValue(args, names) {
-    let value = null;
-    for (let i = 0; i < args.length - 1; i += 1) {
-        if (names.includes(args[i]))
-            value = args[i + 1];
-    }
-    return value;
-}
-/** `-xrm 'XTerm*faceName: Hack'` entries, in the shape `xResources` returns. */
-export function xrmResources(args) {
-    const entries = [];
-    for (let i = 0; i < args.length - 1; i += 1) {
-        if (args[i] !== '-xrm')
-            continue;
-        const colon = args[i + 1].indexOf(':');
-        if (colon !== -1)
-            entries.push([args[i + 1].slice(0, colon).trim(), args[i + 1].slice(colon + 1).trim()]);
-    }
-    return entries;
-}
-/**
- * The value X would give `<class>.<...>.<resource>`, simplified to what
- * terminal users write: `XTerm*faceName`, `xterm.vt100.faceName`, `*faceName`.
- * A named class wins over the bare wildcard.
- */
-export function xResource(resources, classes, resource) {
-    let named = null;
-    let wildcard = null;
-    // Later entries win: `-xrm` options are appended after the database.
-    for (const [name, value] of resources) {
-        const parts = name.split(/[.*]/).filter(Boolean);
-        if (parts[parts.length - 1] !== resource || !value)
-            continue;
-        if (parts.length === 1)
-            wildcard = value;
-        else if (classes.includes(parts[0]))
-            named = value;
-    }
-    return named ?? wildcard;
-}
-/**
- * An X terminal's font name: `xft:JetBrains Mono:size=11` (FreeType, any list
- * takes its first entry) or an XLFD `-misc-dejavu sans mono-medium-r-normal--14-…`.
- * A bare core-font alias (`fixed`, `9x15`) names a bitmap font: no answer —
- * except in xterm's `faceName`, which is always a FreeType pattern.
- */
-export function parseXFontName(value, { bareIsPattern = false } = {}) {
-    const first = String(value || '')
-        .split(/,(?=\s*(?:xft:|-))/)[0]
-        .trim();
-    if (/^xft:/i.test(first))
-        return parseFontconfigPattern(first.slice(4));
-    if (first.startsWith('-')) {
-        const fields = first.split('-');
-        const family = (fields[2] || '').trim();
-        if (!family || family === '*' || /^(fixed|misc)$/i.test(family))
-            return null;
-        const pixels = Number(fields[7]);
-        const decipoints = Number(fields[8]);
-        return {
-            family,
-            sizePx: pixels > 0 ? pixels : decipoints > 0 ? pointsToPx(decipoints / 10) : undefined,
-        };
-    }
-    if (!first)
-        return null;
-    return bareIsPattern || first.includes(':') ? parseFontconfigPattern(first) : null;
-}

package/dist/terminal-font/index.js

@@ -1,187 +0,0 @@
-/**
- * Reads the font the workstation's terminal draws with.
- *
- * Colors can be asked for with OSC queries (see terminal-palette.js); a font
- * cannot. No escape sequence that mainstream emulators answer reports the
- * family, so the host works out which terminal it is running in and reads that
- * terminal's own settings — the same settings dialog the user edited.
- *
- * The answer travels to the browser in `host_hello` as a family name, a size,
- * and the font files the browser may fetch by hash, so a phone draws the
- * session in the face the workstation shows even though it has no such font
- * installed. Nothing here guesses: a terminal this module does not know yields
- * `null`, and the browser keeps its own monospace stack.
- */
-import fs from 'node:fs';
-import { sanitizeTerminalFont, TERMINAL_FONT_CHUNK_BYTES, } from 'herdr-remote-relay/protocol';
-import { readRuntime, writeRuntime } from '../runtime.js';
-import { withDefaults } from './deps.js';
-import { concreteFamily, resolveFontFaces, resolveSubsetSources, } from './files.js';
-import { READERS } from './readers.js';
-import { identifyTerminal, processArguments, processLineage, terminalProcess, } from './terminals.js';
-/** Reads one terminal's configured font: `{ source, family, sizePx }` or null. */
-export function readTerminalFont(source, deps = {}) {
-    const resolved = withDefaults(deps);
-    const reader = READERS[source];
-    if (!reader)
-        return null;
-    let font;
-    try {
-        font = reader(resolved);
-    }
-    catch {
-        return null;
-    }
-    if (!font?.family)
-        return null;
-    const family = concreteFamily(font.family, resolved);
-    if (!family)
-        return null;
-    return sanitizeDetected({ source, family, sizePx: font.sizePx });
-}
-/** Identifies the terminal and reads its font. */
-export function detectTerminalFont({ env = process.env, ancestry, lineage, deps = {}, } = {}) {
-    const processes = lineage ||
-        (ancestry ? ancestry.map((name) => ({ pid: 0, name })) : processLineage({ run: deps.run }));
-    const source = identifyTerminal({ env, ancestry: processes.map((entry) => entry.name) });
-    if (!source)
-        return null;
-    // A terminal configured on its command line (xterm's `-fa`) says so there.
-    const emulator = terminalProcess(source, processes);
-    const terminalArgs = deps.terminalArgs || (emulator?.pid ? processArguments(emulator.pid) : []);
-    return readTerminalFont(source, { ...deps, env, terminalArgs });
-}
-/** What detection reports, before any files are attached. */
-function sanitizeDetected(value) {
-    const clean = sanitizeTerminalFont(value);
-    if (!clean)
-        return null;
-    const detected = { source: clean.source || null, family: clean.family };
-    if (clean.sizePx)
-        detected.sizePx = clean.sizePx;
-    return detected;
-}
-/** The full record a connector serves from: detection plus local files. */
-function describeTerminalFont(detected, deps = {}) {
-    if (!detected?.family)
-        return null;
-    const faces = resolveFontFaces(detected.family, deps);
-    return { ...detected, faces, subsets: resolveSubsetSources(detected.family, faces, deps) };
-}
-/** The same record with the file paths removed: what may leave this machine. */
-export function publicTerminalFont(record) {
-    return record ? sanitizeTerminalFont(record) : null;
-}
-/**
- * One slice of a face, by hash. The file is re-checked against what was
- * announced, so an edited font is refused rather than spliced into a browser's
- * copy of the old one.
- */
-export function readFontChunk(record, sha256, index) {
-    const face = record?.faces?.find((candidate) => candidate.sha256 === sha256);
-    if (!face)
-        return null;
-    const total = Math.ceil(face.bytes / TERMINAL_FONT_CHUNK_BYTES);
-    if (!Number.isInteger(index) || index < 0 || index >= total)
-        return null;
-    let fd;
-    try {
-        const stat = fs.statSync(face.path);
-        if (stat.size !== face.bytes || stat.mtimeMs !== face.mtimeMs)
-            return null;
-        fd = fs.openSync(face.path, 'r');
-        const start = index * TERMINAL_FONT_CHUNK_BYTES;
-        const length = Math.min(TERMINAL_FONT_CHUNK_BYTES, face.bytes - start);
-        const buffer = Buffer.alloc(length);
-        const read = fs.readSync(fd, buffer, 0, length, start);
-        if (read !== length)
-            return null;
-        return { data: buffer, total };
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (fd !== undefined)
-            try {
-                fs.closeSync(fd);
-            }
-            catch {
-                // Closing a read-only descriptor cannot lose data.
-            }
-    }
-}
-/** Reads a font a parent process already detected. */
-export function fontFromEnvironment(env = process.env) {
-    const raw = env.HERDR_TERM_FONT_JSON;
-    if (!raw)
-        return null;
-    try {
-        return sanitizeDetected(JSON.parse(raw));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Remembers the font for a start that has no terminal around it: a service
- * manager's, or Herdr's detached server's.
- */
-function rememberTerminalFont(detected) {
-    const clean = sanitizeDetected(detected);
-    if (!clean)
-        return null;
-    try {
-        const state = readRuntime();
-        const previous = state.terminalFont;
-        if (!previous || JSON.stringify(previous) !== JSON.stringify(clean)) {
-            writeRuntime({ ...state, terminalFont: clean });
-        }
-    }
-    catch {
-        // A font is a nicety; failing to remember it must not break a start.
-    }
-    return clean;
-}
-function rememberedTerminalFont() {
-    try {
-        return sanitizeDetected(readRuntime().terminalFont);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Detect the terminal's font at the entry point, where the terminal's
- * variables and process ancestry are still this process's own, and hand the
- * answer to everything this command starts.
- */
-export function captureTerminalFont({ env = process.env, detect = detectTerminalFont, } = {}) {
-    if (env.HERDR_TERM_FONT_JSON)
-        return fontFromEnvironment(env);
-    const detected = detect({ env });
-    if (!detected)
-        return null;
-    env.HERDR_TERM_FONT_JSON = JSON.stringify(detected);
-    rememberTerminalFont(detected);
-    return detected;
-}
-/** The font a service start hands its children: inherited, else remembered. */
-export function resolveHostFont({ env = process.env } = {}) {
-    return fontFromEnvironment(env) || rememberedTerminalFont();
-}
-/**
- * What the connector serves: the terminal's settings read again now, when the
- * terminal is known, so a font changed since the last start is not reported
- * stale; otherwise what was handed down. `refresh` also re-identifies a
- * terminal nobody had named, for a browser that asks to sync.
- */
-export function loadHostTerminalFont({ env = process.env, refresh = false, deps = {}, } = {}) {
-    const known = resolveHostFont({ env });
-    let current = known?.source ? readTerminalFont(known.source, { ...deps, env }) : null;
-    if (!current && refresh && !known)
-        current = detectTerminalFont({ env, deps });
-    if (current && JSON.stringify(current) !== JSON.stringify(known))
-        rememberTerminalFont(current);
-    return describeTerminalFont(current || known, deps);
-}