oasis-editor 0.0.97 → 0.0.99

package/dist/text/fonts/core/types.d.ts

@@ -51,7 +51,12 @@ export interface ParsedFontProgram {
     getRawTableData(tag: string): Uint8Array | null;
 }
 export interface TextLayouter {
-    layout(text: string): GlyphRun;
+    /**
+     * Lays out `text` into positioned glyphs. `features` lists OpenType GSUB
+     * feature tags to apply (e.g. `["liga", "onum"]`); layouters that don't shape
+     * ignore it and produce a 1:1 codepoint→glyph run.
+     */
+    layout(text: string, features?: readonly string[]): GlyphRun;
 }
 export interface FontSubset {
     readonly fontFile: Uint8Array;

package/dist/text/fonts/layout/OpenTypeLayouter.d.ts

@@ -0,0 +1,21 @@
+import { GlyphRun, ParsedFontProgram, TextLayouter } from '../core/types.js';
+
+/**
+ * A {@link TextLayouter} that applies OpenType GSUB substitution for the editor's
+ * Latin font features (ligatures, figure style, stylistic sets, contextual
+ * alternates) when the font carries a GSUB table and the caller requests them.
+ *
+ * With no requested features — or a font without GSUB — it falls straight back to
+ * the same 1:1 codepoint→glyph mapping as `SimpleTextLayouter`, so ordinary text
+ * is byte-for-byte unchanged. GSUB only substitutes glyphs; advances come from
+ * `hmtx` (GPOS positioning is out of scope), so `positions[].xAdvance` equals each
+ * resulting glyph's advance width.
+ */
+export declare class OpenTypeLayouter implements TextLayouter {
+    private readonly font;
+    private readonly gsub;
+    constructor(font: ParsedFontProgram);
+    /** True when the font exposes a GSUB table the shaper could use. */
+    get hasGsub(): boolean;
+    layout(text: string, features?: readonly string[]): GlyphRun;
+}

package/dist/text/fonts/opentype/GsubTable.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Minimal OpenType GSUB (glyph substitution) parser + apply engine, scoped to the
+ * Latin font features the editor exposes: ligatures (liga/dlig/hlig), figure
+ * style (lnum/onum/pnum/tnum), stylistic sets (ss01–ss20), and contextual
+ * alternates (calt).
+ *
+ * It parses ScriptList/FeatureList/LookupList and the substitution lookup types
+ * those features use — single (1), multiple (2), alternate (3), ligature (4),
+ * chaining contextual (6), and extension (7). Positioning (GPOS), complex-script
+ * shaping, and lookup-flag glyph skipping are intentionally out of scope.
+ *
+ * Parsing is defensive: any malformed offset or unsupported construct is skipped
+ * (the feature simply doesn't apply) rather than throwing, so a broken GSUB can
+ * never break PDF export. All offsets are relative to the start of the GSUB table
+ * bytes passed to {@link GsubTable.parse}.
+ */
+/** A glyph in the shaping buffer, carrying the source code points for ToUnicode. */
+export interface ShapingGlyph {
+    id: number;
+    codePoints: number[];
+}
+export declare class GsubTable {
+    private readonly lookups;
+    private readonly featureToLookups;
+    private constructor();
+    /** Parses GSUB bytes (table-relative). Returns null on any structural failure. */
+    static parse(bytes: Uint8Array): GsubTable | null;
+    /** True when at least one of the requested feature tags exists in this font. */
+    hasAnyFeature(tags: readonly string[]): boolean;
+    /** Ordered (ascending) unique lookup indices referenced by the given tags. */
+    collectLookupIndices(tags: readonly string[]): number[];
+    /**
+     * Applies one lookup (by index) at a single position. Tries each subtable in
+     * order; the first that matches wins. Returns the advance (output glyph count)
+     * or null when nothing matched. Used both by the shaping walk and by nested
+     * chaining-contextual substitution records.
+     */
+    applyLookupIndexAt(lookupIndex: number, glyphs: ShapingGlyph[], pos: number): number | null;
+    /** Applies the lookups for the given features across the whole buffer. */
+    shape(glyphs: ShapingGlyph[], tags: readonly string[]): void;
+}

package/dist/ui/canvas/canvasFontResolution.d.ts

@@ -8,3 +8,31 @@ export declare function resolveCanvasTextRenderMetrics(styles: {
     fontSize: number;
     baselineOffset: number;
 };
+/**
+ * Applies the subset of OpenType-feature/typography intent that Canvas 2D can
+ * actually express, keeping painting consistent with the metric-only slot
+ * measurement (see `measureCharacterWidth`).
+ *
+ * - **Kerning (`w:kern`)** → `ctx.fontKerning`. `w:kern/@w:val` is a *minimum
+ *   font size threshold* (stored in pt as `kerningThreshold`); kerning is active
+ *   only when the run's size meets it. Defaulting to `"none"` keeps the painter
+ *   aligned with the no-kerning measurement, avoiding caret/slot drift.
+ * - **Ligatures (`w14:ligatures`)** → `ctx.textRendering` as a *coarse, lossy
+ *   hint* (`optimizeSpeed` suppresses, `optimizeLegibility` enables). It cannot
+ *   distinguish standard/contextual/historical and is engine-dependent.
+ *
+ * Canvas 2D has **no** API for `w14:numForm`, `w14:numSpacing`,
+ * `w14:stylisticSets`, or `w14:cntxtAlts` (no `fontVariantNumeric` /
+ * `fontVariantLigatures` / `fontFeatureSettings`), so those remain a documented
+ * canvas limitation — HTML/CSS honors them via `styleCss.ts`; PDF is separate.
+ *
+ * `fontVariantCaps`, `letterSpacing`, and `fontStretch` are intentionally left
+ * untouched: small caps, character spacing, and character scale are already
+ * realized by the render-metric/slot/scale path and would double-apply here.
+ *
+ * @param fontSizePx the run's effective (unscaled) font size in px.
+ */
+export declare function applyCanvasTextFeatureHints(ctx: CanvasRenderingContext2D, styles: {
+    kerningThreshold?: number | null;
+    ligatures?: "none" | "standard" | "contextual" | "historical" | "standardContextual" | null;
+} | undefined, fontSizePx: number): void;

package/dist/ui/canvas/canvasParagraphPainter.d.ts

@@ -1,7 +1,7 @@
 import { EditorLayoutLine, EditorPageSettings, EditorParagraphNode, EditorState } from '../../core/model.js';
 import { CanvasBlockPainters } from './canvasBlockPainters.js';
 
-export { resolveCanvasFontFamily, resolveCanvasTextRenderMetrics, } from './canvasFontResolution.js';
+export { applyCanvasTextFeatureHints, resolveCanvasFontFamily, resolveCanvasTextRenderMetrics, } from './canvasFontResolution.js';
 /**
  * Paints the floating images anchored within a paragraph, mirroring
  * `drawFloatingTextBoxesForParagraph`. Split into `behind`/`front` layers so a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oasis-editor",
-  "version": "0.0.97",
+  "version": "0.0.99",
   "type": "module",
   "repository": {
     "type": "git",