restty 0.1.23 → 0.1.25

package/dist/runtime/create-runtime/lifecycle-theme-size.d.ts

@@ -0,0 +1,16 @@
+import type { LifecycleThemeSizeDeps } from "./lifecycle-theme-size.types";
+export declare function createRuntimeLifecycleThemeSize(deps: LifecycleThemeSizeDeps): {
+    applyTheme: (theme: import("../..").GhosttyTheme | null | undefined, sourceLabel?: string) => void;
+    resetTheme: () => void;
+    replaceCanvas: () => void;
+    updateSize: (force?: boolean) => void;
+    resize: (cols: number, rows: number) => void;
+    scheduleSizeUpdate: () => void;
+    focusTypingInput: () => void;
+    focus: () => void;
+    blur: () => void;
+    bindFocusEvents: () => void;
+    bindAutoResizeEvents: () => void;
+    cancelScheduledSizeUpdate: () => void;
+    getActiveTheme: () => import("../..").GhosttyTheme | null;
+};

package/dist/runtime/create-runtime/lifecycle-theme-size.types.d.ts

@@ -0,0 +1,85 @@
+import type { InputHandler } from "../../input";
+import type { FontManagerState } from "../../fonts";
+import type { Color, WebGLState, WebGPUState } from "../../renderer";
+import type { GhosttyTheme } from "../../theme";
+import type { ResttyWasm } from "../../wasm";
+import type { ResttyAppCallbacks } from "../types";
+export type ActiveState = WebGPUState | WebGLState | null;
+export type GridStateRef = {
+    cols: number;
+    rows: number;
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+};
+export type ResizeStateRef = {
+    active: boolean;
+    lastAt: number;
+    cols: number;
+    rows: number;
+    dpr: number;
+};
+export type CanvasStateSnapshot = {
+    width: number;
+    height: number;
+    dpr: number;
+    gridCols: number;
+    gridRows: number;
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+};
+export type LifecycleThemeSizeDeps = {
+    attachCanvasEvents: boolean;
+    attachWindowEvents: boolean;
+    autoResize: boolean;
+    imeInput: HTMLTextAreaElement | null;
+    dprEl: HTMLElement | null;
+    sizeEl: HTMLElement | null;
+    callbacks: ResttyAppCallbacks | undefined;
+    cleanupFns: Array<() => void>;
+    cleanupCanvasFns: Array<() => void>;
+    gridState: GridStateRef;
+    resizeState: ResizeStateRef;
+    fontState: FontManagerState;
+    defaultBgBase: Color;
+    defaultFgBase: Color;
+    selectionBase: Color;
+    cursorBase: Color;
+    getCanvas: () => HTMLCanvasElement;
+    setCanvas: (canvas: HTMLCanvasElement) => void;
+    getCurrentDpr: () => number;
+    setCurrentDpr: (dpr: number) => void;
+    setCurrentContextType: (type: "webgpu" | "webgl2" | null) => void;
+    getActiveState: () => ActiveState;
+    getInputHandler: () => InputHandler | null;
+    setIsFocused: (value: boolean) => void;
+    getActiveTheme: () => GhosttyTheme | null;
+    setActiveTheme: (theme: GhosttyTheme | null) => void;
+    setDefaultBg: (value: Color) => void;
+    setDefaultFg: (value: Color) => void;
+    setSelectionColor: (value: Color) => void;
+    setCursorFallback: (value: Color) => void;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    appendLog: (line: string) => void;
+    bindCanvasEvents: () => void;
+    computeCellMetrics: () => {
+        cellW: number;
+        cellH: number;
+    } | null;
+    updateGrid: () => void;
+    syncKittyOverlaySize: () => void;
+    scheduleTerminalResizeCommit: (cols: number, rows: number, options?: {
+        immediate?: boolean;
+    }) => void;
+    sendKeyInput: (text: string, source?: string) => void;
+    clearWebGLShaderStages: (state?: WebGLState) => void;
+    destroyWebGLStageTargets: (state?: WebGLState) => void;
+    destroyWebGPUStageTargets: () => void;
+    detachKittyOverlayCanvas: () => void;
+    setShaderStagesDirty: (value: boolean) => void;
+    markNeedsRender: () => void;
+    resetLastRenderTime: () => void;
+};

package/dist/runtime/create-runtime/pty-input-runtime.d.ts

@@ -0,0 +1,45 @@
+import type { InputHandler } from "../../input";
+import type { PtyTransport } from "../../pty";
+import type { PtyOutputBufferController } from "../pty-output-buffer";
+type CursorPosition = {
+    row: number;
+    col: number;
+};
+type SendInput = (text: string, source?: string, options?: {
+    skipHooks?: boolean;
+}) => void;
+export type CreatePtyInputRuntimeOptions = {
+    ptyTransport: PtyTransport;
+    ptyOutputBuffer: PtyOutputBufferController;
+    inputHandler: InputHandler;
+    ptyStatusEl?: HTMLElement | null;
+    mouseStatusEl?: HTMLElement | null;
+    onPtyStatus?: ((status: string) => void) | null;
+    onMouseStatus?: ((status: string) => void) | null;
+    appendLog: (line: string) => void;
+    getGridSize: () => {
+        cols: number;
+        rows: number;
+    };
+    getCursorForCpr: () => CursorPosition;
+    sendInput: SendInput;
+    runBeforeInputHook: (text: string, source: string) => string | null;
+    shouldClearSelection: () => boolean;
+    clearSelection: () => void;
+    syncOutputResetMs: number;
+    syncOutputResetSeq: string;
+};
+export type PtyInputRuntime = {
+    setPtyStatus: (text: string) => void;
+    updateMouseStatus: () => void;
+    scheduleSyncOutputReset: () => void;
+    cancelSyncOutputReset: () => void;
+    connectPty: (url?: string) => void;
+    disconnectPty: () => void;
+    sendKeyInput: (text: string, source?: string) => void;
+    sendPasteText: (text: string) => void;
+    sendPastePayloadFromDataTransfer: (dataTransfer: DataTransfer | null | undefined) => boolean;
+    getCprPosition: () => CursorPosition;
+};
+export declare function createPtyInputRuntime(options: CreatePtyInputRuntimeOptions): PtyInputRuntime;
+export {};

package/dist/runtime/create-runtime/render-tick-webgl-context.d.ts

@@ -0,0 +1,4 @@
+import type { WebGLState } from "../../renderer";
+import type { WebGLTickContext, WebGLTickDeps } from "./render-tick-webgl.types";
+export type { WebGLTickContext } from "./render-tick-webgl.types";
+export declare function buildWebGLTickContext(deps: WebGLTickDeps, state: WebGLState): WebGLTickContext | null;

package/dist/runtime/create-runtime/render-tick-webgl-glyph-pipeline.d.ts

@@ -0,0 +1,2 @@
+import type { WebGLTickContext } from "./render-tick-webgl.types";
+export declare function renderWebGLGlyphPipeline(ctx: WebGLTickContext): void;

package/dist/runtime/create-runtime/render-tick-webgl-overlays.d.ts

@@ -0,0 +1,2 @@
+import type { WebGLTickContext } from "./render-tick-webgl-context";
+export declare function populateWebGLOverlays(ctx: WebGLTickContext): void;

package/dist/runtime/create-runtime/render-tick-webgl-scene.d.ts

@@ -0,0 +1,2 @@
+import type { WebGLTickContext } from "./render-tick-webgl-context";
+export declare function populateWebGLSceneData(ctx: WebGLTickContext): void;

package/dist/runtime/create-runtime/render-tick-webgl.d.ts

@@ -0,0 +1,3 @@
+import type { WebGLState } from "../../renderer";
+import type { WebGLTickDeps } from "./render-tick-webgl.types";
+export declare function tickWebGL(deps: WebGLTickDeps, state: WebGLState): void;

package/dist/runtime/create-runtime/render-tick-webgl.types.d.ts

@@ -0,0 +1,162 @@
+import type { FontEntry } from "../../fonts";
+import type { Color, WebGLState } from "../../renderer";
+import type { CursorInfo, RenderState } from "../../wasm";
+import type { CompiledWebGLShaderStage, WebGLStageTargets } from "../create-app-types";
+import type { BuildFontAtlasParams, BuildFontAtlasResult, GlyphConstraintMeta } from "../atlas-builder";
+import type { AlphaBlendingMode } from "./blend-utils";
+import type { CursorPosition, GlyphQueueItem, NerdMetrics, SharedTickDeps, WebGPURenderInput } from "./render-tick-webgpu.types";
+type AtlasBuilderDeps = BuildFontAtlasParams["deps"];
+export type WebGLTickDeps = SharedTickDeps & {
+    isShaderStagesDirty: () => boolean;
+    rebuildWebGLShaderStages: (state: WebGLState) => void;
+    setShaderStagesDirty: (value: boolean) => void;
+    getCompiledWebGLShaderStages: () => CompiledWebGLShaderStage[];
+    ensureWebGLStageTargets: (state: WebGLState) => WebGLStageTargets | null;
+    fontError: Error | null;
+    termDebug: HTMLElement | null;
+    reportDebugText: (text: string) => void;
+    updateGrid: () => void;
+    getRenderState: () => RenderState | null;
+    clearKittyOverlay: () => void;
+    resolveBlendFlags: (alphaMode: AlphaBlendingMode, backend: "webgl2") => {
+        useLinearBlending: boolean;
+        useLinearCorrection: boolean;
+    };
+    alphaBlending: AlphaBlendingMode;
+    reportTermSize: (cols: number, rows: number) => void;
+    resolveCursorPosition: (cursor: CursorInfo | null) => CursorPosition | null;
+    reportCursor: (cursor: {
+        col: number;
+        row: number;
+    } | null) => void;
+    FORCE_CURSOR_BLINK: boolean;
+    CURSOR_BLINK_MS: number;
+    imeInput: HTMLTextAreaElement | null;
+    resolveCursorStyle: (cursor: CursorInfo, opts: {
+        focused: boolean;
+        preedit: boolean;
+        blinkVisible: boolean;
+    }) => number | null;
+    isFocused: boolean;
+    imeState: {
+        preedit: string;
+        selectionStart: number;
+        selectionEnd: number;
+    };
+    resolveImeAnchor: (cursor: CursorPosition | null, cols: number, rows: number) => {
+        row: number;
+        col: number;
+    } | null;
+    gridState: {
+        cellW: number;
+        cellH: number;
+        fontSizePx: number;
+        scale: number;
+        lineHeight: number;
+        baselineOffset: number;
+        yPad: number;
+    };
+    updateImePosition: (cursor: {
+        row: number;
+        col: number;
+    }, cellW: number, cellH: number) => void;
+    canvas: HTMLCanvasElement;
+    buildFontAtlasIfNeeded: (params: BuildFontAtlasParams) => BuildFontAtlasResult;
+    resolveGlyphPixelMode: AtlasBuilderDeps["resolveGlyphPixelMode"];
+    atlasBitmapToRGBA: AtlasBuilderDeps["atlasBitmapToRGBA"];
+    padAtlasRGBA: AtlasBuilderDeps["padAtlasRGBA"];
+    buildAtlas: AtlasBuilderDeps["buildAtlas"];
+    buildGlyphAtlasWithConstraints: AtlasBuilderDeps["buildGlyphAtlasWithConstraints"];
+    buildColorEmojiAtlasWithCanvas: AtlasBuilderDeps["buildColorEmojiAtlasWithCanvas"];
+    rasterizeGlyph: AtlasBuilderDeps["rasterizeGlyph"];
+    rasterizeGlyphWithTransform: AtlasBuilderDeps["rasterizeGlyphWithTransform"];
+    nerdConstraintSignature: AtlasBuilderDeps["nerdConstraintSignature"];
+    ATLAS_PADDING: number;
+    SYMBOL_ATLAS_PADDING: number;
+    SYMBOL_ATLAS_MAX_SIZE: number;
+    PixelMode: {
+        RGBA?: number;
+    };
+    ensureGLInstanceBuffer: (state: WebGLState, kind: "rect" | "glyph", minBytes: number) => void;
+    GLYPH_INSTANCE_FLOATS: number;
+    wasmHandle: number;
+    lastRenderState: RenderState | null;
+};
+export type WebGLCursorCell = {
+    row: number;
+    col: number;
+    wide: boolean;
+};
+export type WebGLTickContext = {
+    deps: WebGLTickDeps;
+    state: WebGLState;
+    rows: number;
+    cols: number;
+    codepoints: WebGPURenderInput["codepoints"];
+    contentTags: WebGPURenderInput["contentTags"];
+    wide: WebGPURenderInput["wide"];
+    styleFlags: WebGPURenderInput["styleFlags"];
+    linkIds: WebGPURenderInput["linkIds"];
+    fgBytes: WebGPURenderInput["fgBytes"];
+    bgBytes: WebGPURenderInput["bgBytes"];
+    ulBytes: WebGPURenderInput["ulBytes"];
+    ulStyle: WebGPURenderInput["ulStyle"];
+    graphemeOffset: WebGPURenderInput["graphemeOffset"];
+    graphemeLen: WebGPURenderInput["graphemeLen"];
+    graphemeBuffer: WebGPURenderInput["graphemeBuffer"];
+    cursor: RenderState["cursor"];
+    mergedEmojiSkip: Uint8Array;
+    readCellCluster: (cellIndex: number) => {
+        cp: number;
+        text: string;
+        span: number;
+    } | null;
+    useLinearBlending: boolean;
+    useLinearCorrection: boolean;
+    blinkVisible: boolean;
+    cursorPos: CursorPosition | null;
+    cursorStyle: number | null;
+    cursorCell: WebGLCursorCell | null;
+    cursorImeAnchor: {
+        row: number;
+        col: number;
+    } | null;
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+    primaryEntry: FontEntry | undefined;
+    primaryScale: number;
+    lineHeight: number;
+    baselineOffset: number;
+    yPad: number;
+    underlineOffsetPx: number;
+    underlineThicknessPx: number;
+    bgData: number[];
+    selectionData: number[];
+    underlineData: number[];
+    cursorData: number[];
+    fgRectData: number[];
+    overlayData: number[];
+    glyphDataByFont: Map<number, number[]>;
+    glyphQueueByFont: Map<number, GlyphQueueItem[]>;
+    overlayGlyphDataByFont: Map<number, number[]>;
+    overlayGlyphQueueByFont: Map<number, GlyphQueueItem[]>;
+    neededGlyphIdsByFont: Map<number, Set<number>>;
+    neededGlyphMetaByFont: Map<number, Map<number, GlyphConstraintMeta>>;
+    fgColorCache: Map<number, Color>;
+    bgColorCache: Map<number, Color>;
+    ulColorCache: Map<number, Color>;
+    scaleByFont: number[];
+    bitmapScaleByFont: number[];
+    baselineAdjustByFont: number[];
+    nerdMetrics: NerdMetrics;
+    getGlyphQueue: (fontIndex: number) => GlyphQueueItem[];
+    getOverlayGlyphQueue: (fontIndex: number) => GlyphQueueItem[];
+    getGlyphSet: (fontIndex: number) => Set<number>;
+    noteGlyphMeta: (fontIndex: number, glyphId: number, cp: number, constraintWidth: number) => void;
+    getGlyphData: (map: Map<number, number[]>, fontIndex: number) => number[];
+    compiledWebGLStages: CompiledWebGLShaderStage[];
+    stageTargets: WebGLStageTargets | null;
+    hasShaderStages: boolean;
+};
+export {};

package/dist/runtime/create-runtime/render-tick-webgpu-cell-pass.d.ts

@@ -0,0 +1,25 @@
+import type { GlyphConstraintMeta } from "../atlas-builder";
+import type { CollectWebGPUCellPassParams, GlyphQueueItem } from "./render-tick-webgpu.types";
+export declare function collectWebGPUCellPass(params: CollectWebGPUCellPassParams): {
+    bgData: number[];
+    selectionData: number[];
+    underlineData: number[];
+    cursorData: number[];
+    fgRectData: number[];
+    overlayData: number[];
+    glyphDataNearestByFont: Map<number, number[]>;
+    glyphDataLinearByFont: Map<number, number[]>;
+    glyphQueueByFont: Map<number, GlyphQueueItem[]>;
+    overlayGlyphDataNearestByFont: Map<number, number[]>;
+    overlayGlyphDataLinearByFont: Map<number, number[]>;
+    overlayGlyphQueueByFont: Map<number, GlyphQueueItem[]>;
+    neededGlyphIdsByFont: Map<number, Set<number>>;
+    neededGlyphMetaByFont: Map<number, Map<number, GlyphConstraintMeta>>;
+    scaleByFont: number[];
+    bitmapScaleByFont: number[];
+    baselineAdjustByFont: number[];
+    nerdMetrics: import("./render-tick-webgpu.types").NerdMetrics;
+    getGlyphQueue: (fontIndex: number) => GlyphQueueItem[];
+    getOverlayGlyphQueue: (fontIndex: number) => GlyphQueueItem[];
+    getGlyphSet: (fontIndex: number) => Set<number>;
+};

package/dist/runtime/create-runtime/render-tick-webgpu-draw-pass.d.ts

@@ -0,0 +1,2 @@
+import type { DrawWebGPUFrameParams } from "./render-tick-webgpu.types";
+export declare function drawWebGPUFrame(params: DrawWebGPUFrameParams): void;

package/dist/runtime/create-runtime/render-tick-webgpu-emit-glyphs.d.ts

@@ -0,0 +1,2 @@
+import type { EmitWebGPUQueuedGlyphsParams } from "./render-tick-webgpu.types";
+export declare function emitWebGPUQueuedGlyphs(params: EmitWebGPUQueuedGlyphsParams): void;

package/dist/runtime/create-runtime/render-tick-webgpu-overlays-atlas.d.ts

@@ -0,0 +1,2 @@
+import type { AugmentWebGPUFrameParams } from "./render-tick-webgpu.types";
+export declare function augmentWebGPUFrameWithOverlaysAndAtlas(params: AugmentWebGPUFrameParams): void;

package/dist/runtime/create-runtime/render-tick-webgpu.d.ts

@@ -0,0 +1,3 @@
+import type { WebGPUState } from "../../renderer";
+import type { RuntimeTickDeps } from "./render-tick-webgpu.types";
+export declare function tickWebGPU(deps: RuntimeTickDeps, state: WebGPUState): void;