@quillmark/quillify 0.3.1 → 0.5.0

package/NOTICE

@@ -1,5 +1,5 @@
 quillify
-Copyright 2026 Nibs
+Copyright 2026 Enrique Oti
 
 quillify redistributes eight files that are other projects' work. Everything
 else it depends on is installed by its consumer and is not in the package.

package/dist/api.d.ts

@@ -41,6 +41,7 @@ export interface FieldNaming {
     /** A read-only field is left out whatever this says. */
     keep: boolean;
     name: string;
+    title?: string;
     description: string;
     example?: string;
     text?: 'line' | 'paragraph' | 'lines';

package/dist/assemble.d.ts

@@ -1,5 +1,5 @@
 import type { InventoryWidget, QualifiedField, QualifiedForm, QuillTree } from './types.js';
-/** What the assembly reads of a field, of the form and of a widget. Its tests hand it a title, which it does not read. */
+/** What the assembly reads of a field, of the form and of a widget. Its tests hand it a quill title, which it does not read. */
 type Named = Omit<QualifiedField, 'label'>;
 type Qualified = {
     quill: Pick<QualifiedForm['quill'], 'name' | 'description'> & {

package/dist/assemble.js

@@ -1,35 +1,27 @@
 /** Every quill the library builds is a first version. */
 export const QUILL_VERSION = '0.1.0';
 /**
- * A string as a YAML double-quoted scalar. JSON writes it, from a well formed
- * string, and the characters the engine's reader refuses and JSON leaves raw
- * (U+007F to U+009F, U+FFFE and U+FFFF) are written as `\u` escapes.
+ * JSON as YAML the engine reads: the characters its reader refuses and JSON
+ * leaves raw (U+007F to U+009F, U+FFFE and U+FFFF) are written as `\u` escapes.
  */
-const q = (s) => JSON.stringify(s.toWellFormed()).replace(/[\u007f-\u009f\ufffe\uffff]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
-/** A group id is snake_case; a radio group's PDF name is whatever its author typed. */
-function groupId(name) {
-    const id = name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '');
-    return /^[a-z]/.test(id) ? id : `group_${id}`;
-}
+const escaped = (json) => json.replace(/[\u007f-\u009f\ufffe\uffff]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+/** A string as a YAML double-quoted scalar, which JSON writes from a well formed string. */
+const q = (s) => escaped(JSON.stringify(s.toWellFormed()));
 /**
  * A `default:` says nobody need answer the field. A required field declares
  * none, a boolean apart: it defaults to false either way.
  */
 function fieldYaml(field) {
     const lines = [`    ${q(field.name)}:`];
-    const ui = [];
-    if (field.group)
-        ui.push(`        group: ${q(groupId(field.group))}`);
+    if (field.title !== undefined)
+        lines.push(`      title: ${q(field.title)}`);
     switch (field.type) {
         case 'string':
-            lines.push('      type: string');
+            lines.push('      type: text');
             if (!field.required)
                 lines.push('      default: ""');
             if (field.multiline)
-                ui.push('        multiline: true');
+                lines.push('      multiline: true');
             break;
         case 'boolean':
             lines.push('      type: boolean', '      default: false');
@@ -40,7 +32,7 @@ function fieldYaml(field) {
             // It refuses ";", ">" and "|" in a value too, so a dropdown with one is a text box.
             const values = (field.options ?? []).filter((option) => option !== '');
             if (values.length === 0 || values.some((value) => /[;>|]/.test(value)))
-                lines.push('      type: string');
+                lines.push('      type: text');
             else {
                 lines.push('      type: enum', '      values:');
                 for (const value of values)
@@ -51,14 +43,11 @@ function fieldYaml(field) {
             break;
         }
         case 'array':
-            lines.push('      type: array', '      items:', '        type: string');
+            lines.push('      type: array', '      items:', '        type: text');
             if (!field.required)
                 lines.push('      default: []');
-            ui.push('        multiline: true');
             break;
     }
-    if (ui.length > 0)
-        lines.push('      ui:', ...ui);
     lines.push(`      description: ${q(field.description)}`);
     return lines;
 }
@@ -74,9 +63,6 @@ export function quillYaml(form, fields) {
         '  body:',
         '    enabled: false'
     ];
-    const groups = [...new Set(fields.flatMap((f) => (f.group ? [groupId(f.group)] : [])))];
-    if (groups.length > 0)
-        lines.push('  ui:', `    groups: [${groups.map(q).join(', ')}]`);
     if (fields.length > 0) {
         lines.push('  fields:');
         for (const field of fields)
@@ -142,7 +128,7 @@ export function assembleQuill(form, inventory, formPdf) {
     const tree = new Map([
         ['Quill.yaml', encoder.encode(quillYaml(form, bound))],
         ['form.pdf', formPdf],
-        ['form.json', encoder.encode(JSON.stringify(formJson, null, 2) + '\n')]
+        ['form.yaml', encoder.encode(escaped(JSON.stringify(formJson, null, 2)) + '\n')]
     ]);
     const example = exampleMarkdown(form, bound);
     if (example)

package/dist/display-list.js

@@ -274,12 +274,13 @@ function svgOnly(tag) {
  * One run per visual line, with the box the browser measured it into. Splitting
  * where the rect top changes is what keeps a wrapped paragraph's second line at
  * its own baseline. A tab ends a run too and is in none: the text after it
- * starts a run at the box the layout moved it to.
+ * starts a run at the box the layout moved it to. A soft hyphen the layout
+ * breaks a line at is a hyphen in the run it ends, which is measured with it.
  */
 function collectText(node, X, Y, drawn, turns) {
-    const text = node.nodeValue;
+    let text = node.nodeValue ?? '';
     const parent = node.parentElement;
-    if (!text || !text.trim() || !parent)
+    if (!text.trim() || !parent)
         return;
     // A <select> is de-chromed above; only the option the form shows is drawn.
     if (parent.tagName === 'OPTION' && !parent.selected)
@@ -347,10 +348,15 @@ function collectText(node, X, Y, drawn, turns) {
         }
         range.setStart(node, i);
         range.setEnd(node, i + 1);
-        const rect = range.getClientRects()[0];
+        // At a break the soft hyphen has an empty rect and then the box of the
+        // hyphen shown, and the letter after it has that box and then its own.
+        const rects = range.getClientRects();
+        const rect = rects[rects.length - 1];
         if (!rect)
             continue;
         const glyph = upright(rect);
+        if (text[i] === '\u00ad' && glyph.right > glyph.x)
+            text = `${text.slice(0, i)}-${text.slice(i + 1)}`;
         if (top === null || Math.abs(glyph.top - top) < 0.6) {
             top ??= glyph.top;
             box = box

package/dist/naming.js

@@ -74,6 +74,8 @@ function shaped({ name, description, fields }) {
             not(`${slot}.name`, 'a string');
         if (typeof entry.description !== 'string')
             not(`${slot}.description`, 'a string');
+        if (entry.title !== undefined && typeof entry.title !== 'string')
+            not(`${slot}.title`, 'a string');
         if (entry.example !== undefined && typeof entry.example !== 'string')
             not(`${slot}.example`, 'a string');
         if (entry.text !== undefined && !TEXT.has(entry.text))

package/dist/quillify.js

@@ -50,12 +50,12 @@ export async function quillify(form, naming) {
             return {
                 widget: entry.id,
                 name: entry.name,
+                ...(entry.title === undefined ? {} : { title: entry.title }),
                 description: entry.description,
                 ...typed(field, entry.text),
                 ...(example === undefined ? {} : { example }),
                 keep: entry.keep && !field.readOnly,
-                required: field.required,
-                ...(field.kind === 'radio' ? { group: field.group } : {})
+                required: field.required
             };
         })
     }, {

package/dist/types.d.ts

@@ -62,6 +62,7 @@ export interface QualifiedField {
     /** snake_case schema field name */
     name: string;
     label: string;
+    title?: string;
     description: string;
     type: FieldType;
     multiline: boolean;
@@ -70,8 +71,6 @@ export interface QualifiedField {
     keep: boolean;
     /** `/Ff` bit 2: the form says this one has to be filled. */
     required: boolean;
-    /** The radio group this option belongs to, when it is one. */
-    group?: string;
 }
 export interface QualifiedForm {
     quill: {
@@ -82,7 +81,7 @@ export interface QualifiedForm {
     fields: QualifiedField[];
 }
 export declare const SNAKE_CASE: RegExp;
-/** A quill as files, the shape `Quill.fromTree` and a quiver both take. */
+/** A quill as files, the shape `Quill.fromTree` takes. */
 export type QuillTree = Map<string, Uint8Array>;
 /** The largest file `sanitize` opens. It bounds the compressed input. */
 export declare const MAX_BYTES: number;

package/dist/xfa-widgets.d.ts

@@ -8,7 +8,7 @@ export interface XfaWidget {
     name: string;
     kind: XfaKind;
     page: number;
-    /** Points, top-left origin, page-relative: the rect `form.json` wants. */
+    /** Points, top-left origin, page-relative: the rect `form.yaml` wants. */
     x: number;
     y: number;
     w: number;

package/dist/xfa.js

@@ -54,9 +54,11 @@ export async function xfaToAcroForm(bytes, signal) {
                     construct: 'image',
                     detail: 'pixels'
                 });
-            for (const widget of harvestWidgets(laid, number))
+            const harvested = harvestWidgets(laid, number);
+            for (const widget of harvested)
                 widgets.push(widget);
-            await paint(out.addPage([list.width, list.height]), number, list, async (name) => {
+            const shown = whiten(list, harvested);
+            await paint(out.addPage([list.width, list.height]), number, shown, async (name) => {
                 let font = fonts.get(name);
                 if (!font)
                     fonts.set(name, (font = await out.embedFont(name)));
@@ -71,6 +73,28 @@ export async function xfaToAcroForm(bytes, signal) {
         await opened?.close();
     }
 }
+/**
+ * The engine fills every field in black, whatever colour the form gives its
+ * text. A field whose middle lies on a fill that black reads on at under 4.5:1,
+ * WCAG's floor for text, gets a white box drawn just over that fill.
+ */
+function whiten(list, widgets) {
+    const drawn = [...list.drawn];
+    const filled = (item) => 'edges' in item && item.fill !== null;
+    for (const { x, y, w, h } of widgets) {
+        const [u, v] = [x + w / 2, y + h / 2];
+        const at = drawn.findLastIndex((item) => filled(item) && item.x <= u && u <= item.x + item.w && item.y <= v && v <= item.y + item.h);
+        const under = drawn[at];
+        if (at >= 0 && filled(under) && (luminance(under.fill) + 0.05) / 0.05 < 4.5)
+            drawn.splice(at + 1, 0, { x, y, w, h, fill: [1, 1, 1], edges: [null, null, null, null] });
+    }
+    return { ...list, drawn };
+}
+/** The relative luminance WCAG gives a colour in sRGB. */
+function luminance(colour) {
+    const [r, g, b] = colour.map((c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
 /** PDF's origin is bottom-left; every primitive arrives top-left. */
 async function paint(page, pageNumber, list, font) {
     const H = list.height;
@@ -184,7 +208,8 @@ async function drawRun(page, pageNumber, run, H, get) {
     // The standard-14 text fonts encode WinAnsi alone. U+2010 and U+2011 are
     // drawn as its hyphen, and any other character outside it in the first of
     // SYMBOLS that holds it. A soft hyphen is left out: WinAnsi has it as a
-    // hyphen, and the browser lays it out at no width and shows nothing.
+    // hyphen, and the browser lays it out at no width and shows nothing. The
+    // one it breaks a line at is a hyphen in the run already.
     // Dropping the run would lose a line of the form without anything
     // reporting it.
     // pdf-lib kerns the width it measures and writes no kerning, so the width

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/quillify",
-	"version": "0.3.1",
+	"version": "0.5.0",
 	"description": "Turn a published PDF form (AcroForm or XFA) into a Quillmark quill, in the browser.",
 	"type": "module",
 	"license": "Apache-2.0",
@@ -48,7 +48,7 @@
 	},
 	"devDependencies": {
 		"@neslinesli93/qpdf-wasm": "0.3.0",
-		"@quillmark/wasm": "0.124.0",
+		"@quillmark/wasm": "0.126.0",
 		"@types/node": "24.19.0",
 		"@vitest/browser-playwright": "5.0.2",
 		"fast-check": "4.10.2",
@@ -63,7 +63,7 @@
 		"pdfjs-dist": "6.4.299"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.124.0"
+		"@quillmark/wasm": ">=0.126.0"
 	},
 	"publishConfig": {
 		"access": "public"