@rezi-ui/core 0.1.0-alpha.7 → 0.1.0-alpha.71

package/dist/renderer/renderToDrawlist/damageBounds.js

@@ -0,0 +1,28 @@
+import { getRectWithShadow, readShadowOffset } from "../shadow.js";
+function resolveShadowOffsets(shadow) {
+    if (shadow !== true && (shadow === false || shadow === undefined || shadow === null)) {
+        return null;
+    }
+    if (shadow === true) {
+        return Object.freeze({ offsetX: 1, offsetY: 1 });
+    }
+    if (typeof shadow !== "object") {
+        return null;
+    }
+    const config = shadow;
+    const offsetX = readShadowOffset(config.offsetX, 1);
+    const offsetY = readShadowOffset(config.offsetY, 1);
+    if (offsetX <= 0 && offsetY <= 0) {
+        return null;
+    }
+    return Object.freeze({ offsetX, offsetY });
+}
+export function getRuntimeNodeDamageRect(node, rect) {
+    if (node.vnode.kind !== "box")
+        return rect;
+    const offsets = resolveShadowOffsets(node.vnode.props.shadow);
+    if (!offsets)
+        return rect;
+    return getRectWithShadow(rect, offsets);
+}
+//# sourceMappingURL=damageBounds.js.map

package/dist/renderer/renderToDrawlist/damageBounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"damageBounds.js","sourceRoot":"","sources":["../../../src/renderer/renderToDrawlist/damageBounds.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMnE,SAAS,oBAAoB,CAC3B,MAAe;IAEf,IAAI,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,IAAI,CAAC,EAAE,CAAC;QACrF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;IACnD,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,MAAM,GAAG,MAAkD,CAAC;IAClE,MAAM,OAAO,GAAG,gBAAgB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACpD,MAAM,OAAO,GAAG,gBAAgB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACpD,IAAI,OAAO,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,IAAqB,EAAE,IAAU;IACxE,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK;QAAE,OAAO,IAAI,CAAC;IAC3C,MAAM,OAAO,GAAG,oBAAoB,CAAE,IAAI,CAAC,KAAK,CAAC,KAAwB,CAAC,MAAM,CAAC,CAAC;IAClF,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B,OAAO,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC1C,CAAC"}

package/dist/renderer/renderToDrawlist/renderPackets.d.ts

@@ -0,0 +1,43 @@
+import type { DrawlistBuildResult, DrawlistBuilder, DrawlistTextRunSegment } from "../../drawlist/types.js";
+import type { RuntimeInstance } from "../../runtime/commit.js";
+import type { FocusState } from "../../runtime/focus.js";
+import type { RenderPacket } from "../../runtime/renderPacket.js";
+import type { Theme } from "../../theme/theme.js";
+import type { ResolvedTextStyle } from "./textStyle.js";
+import type { CursorInfo } from "./types.js";
+export declare function computeRenderPacketKey(node: RuntimeInstance, theme: Theme, parentStyle: ResolvedTextStyle, rectWidth: number, rectHeight: number, focusState: FocusState, pressedId: string | null, tick: number, cursorInfo: CursorInfo | undefined): number;
+export declare class RenderPacketRecorder implements DrawlistBuilder {
+    private readonly target;
+    private readonly originX;
+    private readonly originY;
+    private ops;
+    private resources;
+    private readonly blobResourceById;
+    private readonly textRunByBlobId;
+    private valid;
+    constructor(target: DrawlistBuilder, originX: number, originY: number);
+    buildPacket(): RenderPacket | null;
+    private localX;
+    private localY;
+    private invalidatePacket;
+    clear(): void;
+    clearTo(cols: number, rows: number, style?: Parameters<DrawlistBuilder["clearTo"]>[2]): void;
+    fillRect(x: number, y: number, w: number, h: number, style?: Parameters<DrawlistBuilder["fillRect"]>[4]): void;
+    blitRect(srcX: number, srcY: number, w: number, h: number, dstX: number, dstY: number): void;
+    drawText(x: number, y: number, text: string, style?: Parameters<DrawlistBuilder["drawText"]>[3]): void;
+    pushClip(x: number, y: number, w: number, h: number): void;
+    popClip(): void;
+    addBlob(bytes: Uint8Array): number | null;
+    addTextRunBlob(segments: readonly DrawlistTextRunSegment[]): number | null;
+    drawTextRun(x: number, y: number, blobIndex: number): void;
+    setCursor(...args: Parameters<DrawlistBuilder["setCursor"]>): void;
+    hideCursor(): void;
+    setLink(...args: Parameters<DrawlistBuilder["setLink"]>): void;
+    drawCanvas(...args: Parameters<DrawlistBuilder["drawCanvas"]>): void;
+    drawImage(...args: Parameters<DrawlistBuilder["drawImage"]>): void;
+    buildInto(dst: Uint8Array): DrawlistBuildResult;
+    build(): DrawlistBuildResult;
+    reset(): void;
+}
+export declare function emitRenderPacket(builder: DrawlistBuilder, packet: RenderPacket, originX: number, originY: number): void;
+//# sourceMappingURL=renderPackets.d.ts.map

package/dist/renderer/renderToDrawlist/renderPackets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderPackets.d.ts","sourceRoot":"","sources":["../../../src/renderer/renderToDrawlist/renderPackets.ts"],"names":[],"mappings":"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"}

package/dist/renderer/renderToDrawlist/renderPackets.js

@@ -0,0 +1,574 @@
+import { measureTextCells } from "../../layout/textMeasure.js";
+const FNV_OFFSET = 0x811c9dc5;
+const FNV_PRIME = 0x01000193;
+const HASH_MASK_32 = 0xffff_ffff;
+const refIds = new WeakMap();
+let nextRefId = 1;
+const themeHashCache = new WeakMap();
+const styleHashCache = new WeakMap();
+const textValueHashCache = new Map();
+const TEXT_VALUE_HASH_CACHE_MAX = 8_192;
+const TEXT_VALUE_HASH_CACHE_MIN_LEN = 24;
+const textPacketKeyMemo = new WeakMap();
+function hashString(value) {
+    let hash = FNV_OFFSET;
+    for (let i = 0; i < value.length; i++) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, FNV_PRIME) >>> 0;
+    }
+    return hash >>> 0;
+}
+function hashTextValue(value) {
+    if (value.length < TEXT_VALUE_HASH_CACHE_MIN_LEN) {
+        return hashString(value);
+    }
+    const cached = textValueHashCache.get(value);
+    if (cached !== undefined)
+        return cached;
+    const hashed = hashString(value);
+    if (textValueHashCache.size >= TEXT_VALUE_HASH_CACHE_MAX) {
+        // Bound memory under high-cardinality dynamic text workloads.
+        textValueHashCache.clear();
+    }
+    textValueHashCache.set(value, hashed);
+    return hashed;
+}
+function mixHash(hash, value) {
+    const mixed = Math.imul((hash ^ (value >>> 0)) >>> 0, FNV_PRIME);
+    return mixed >>> 0;
+}
+function hashUnknown(value) {
+    if (value === null || value === undefined)
+        return 0;
+    if (typeof value === "number")
+        return (Math.trunc(value) & HASH_MASK_32) >>> 0;
+    if (typeof value === "boolean")
+        return value ? 1 : 2;
+    if (typeof value === "string")
+        return hashString(value);
+    if (typeof value === "symbol")
+        return hashString(String(value));
+    if (typeof value === "bigint")
+        return Number(value & 0xffffffffn) >>> 0;
+    if (typeof value === "object" || typeof value === "function") {
+        const key = value;
+        const cached = refIds.get(key);
+        if (cached !== undefined)
+            return cached >>> 0;
+        const id = nextRefId++;
+        refIds.set(key, id);
+        return id >>> 0;
+    }
+    return 0;
+}
+/**
+ * Hash a value by content for primitives, by identity for objects/functions.
+ * Returns null if the value contains unhashable content (signals uncacheable).
+ */
+function hashPropValue(hash, value) {
+    if (value === null || value === undefined)
+        return mixHash(hash, 0);
+    if (typeof value === "boolean")
+        return mixHash(hash, value ? 1 : 2);
+    if (typeof value === "number")
+        return mixHash(hash, (Math.trunc(value) & HASH_MASK_32) >>> 0);
+    if (typeof value === "string")
+        return mixHash(hash, hashString(value));
+    // Functions (callbacks) don't affect visual output — skip with stable sentinel.
+    if (typeof value === "function")
+        return mixHash(hash, 0xcafe_0001);
+    // Arrays: hash element count + each element.
+    if (Array.isArray(value)) {
+        let out = mixHash(hash, value.length);
+        for (let i = 0; i < value.length; i++) {
+            out = hashPropValue(out, value[i]);
+        }
+        return out;
+    }
+    // Plain objects: hash by identity (preserving correctness for complex nested objects).
+    return mixHash(hash, hashUnknown(value));
+}
+/**
+ * Hash all own enumerable props of an object by content (primitives) or identity (objects).
+ * Callbacks (functions) receive a stable sentinel so re-created closures don't bust the cache.
+ */
+function hashPropsShallow(hash, props) {
+    let out = hash;
+    const keys = Object.keys(props);
+    out = mixHash(out, keys.length);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (key === undefined)
+            continue;
+        out = mixHash(out, hashString(key));
+        out = hashPropValue(out, props[key]);
+    }
+    return out;
+}
+function hashBoolFlag(value) {
+    if (value === true)
+        return 1;
+    if (value === false)
+        return 2;
+    return 0;
+}
+function hashTheme(theme) {
+    const cached = themeHashCache.get(theme);
+    if (cached !== undefined)
+        return cached;
+    let hash = FNV_OFFSET;
+    const keys = Object.keys(theme.colors).sort();
+    for (const key of keys) {
+        hash = mixHash(hash, hashString(key));
+        hash = mixHash(hash, (theme.colors[key] ?? 0) >>> 0);
+    }
+    for (let i = 0; i < theme.spacing.length; i++) {
+        hash = mixHash(hash, (Math.trunc(theme.spacing[i] ?? 0) & HASH_MASK_32) >>> 0);
+    }
+    hash = mixHash(hash, theme.focusIndicator.bold ? 1 : 2);
+    hash = mixHash(hash, theme.focusIndicator.underline ? 1 : 2);
+    const hasFocusRingColor = theme.focusIndicator.focusRingColor !== undefined;
+    hash = mixHash(hash, hasFocusRingColor ? 1 : 2);
+    if (hasFocusRingColor) {
+        hash = mixHash(hash, (Math.trunc(theme.focusIndicator.focusRingColor ?? 0) & HASH_MASK_32) >>> 0);
+    }
+    const out = hash === 0 ? 1 : hash >>> 0;
+    themeHashCache.set(theme, out);
+    return out;
+}
+function hashResolvedStyle(style) {
+    const key = style;
+    const cached = styleHashCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    let hash = FNV_OFFSET;
+    hash = mixHash(hash, (style.fg ?? 0) >>> 0);
+    hash = mixHash(hash, (style.bg ?? 0) >>> 0);
+    hash = mixHash(hash, style.attrs >>> 0);
+    hash = mixHash(hash, hashBoolFlag(style.bold));
+    hash = mixHash(hash, hashBoolFlag(style.dim));
+    hash = mixHash(hash, hashBoolFlag(style.italic));
+    hash = mixHash(hash, hashBoolFlag(style.underline));
+    hash = mixHash(hash, hashBoolFlag(style.inverse));
+    hash = mixHash(hash, hashBoolFlag(style.strikethrough));
+    hash = mixHash(hash, hashBoolFlag(style.overline));
+    hash = mixHash(hash, hashBoolFlag(style.blink));
+    hash = mixHash(hash, hashUnknown(style.underlineStyle));
+    hash = mixHash(hash, hashUnknown(style.underlineColor));
+    const out = hash === 0 ? 1 : hash >>> 0;
+    styleHashCache.set(key, out);
+    return out;
+}
+function hasTerminalCursorFocus(node, cursorInfo) {
+    if (cursorInfo === undefined)
+        return false;
+    if (node.vnode.kind !== "text" && node.vnode.kind !== "richText")
+        return false;
+    const props = node.vnode.props;
+    return (props.internal_terminalCursorFocus ?? props.terminalCursorFocus) === true;
+}
+function isRenderPacketCacheable(node, cursorInfo) {
+    if (hasTerminalCursorFocus(node, cursorInfo))
+        return false;
+    switch (node.vnode.kind) {
+        case "text":
+        case "richText":
+        case "badge":
+        case "spinner":
+        case "icon":
+        case "kbd":
+        case "status":
+        case "tag":
+        case "divider":
+        case "progress":
+        case "gauge":
+        case "skeleton":
+        case "spacer":
+        case "empty":
+        case "errorDisplay":
+        case "callout":
+        case "canvas":
+        case "image":
+        case "lineChart":
+        case "scatter":
+        case "heatmap":
+        case "sparkline":
+        case "barChart":
+        case "miniChart":
+        case "button":
+        case "select":
+        case "checkbox":
+        case "radioGroup":
+        case "slider":
+            return true;
+        default:
+            return false;
+    }
+}
+function focusPressedBits(node, focusState, pressedId) {
+    const props = node.vnode.props;
+    const id = typeof props.id === "string" && props.id.length > 0 ? props.id : null;
+    if (id === null)
+        return 0;
+    const focused = focusState.focusedId === id;
+    const pressed = pressedId === id;
+    return (focused ? 1 : 0) | (pressed ? 2 : 0);
+}
+function isTickDrivenKind(kind) {
+    return kind === "spinner";
+}
+/**
+ * Fast-path prop hashing for text/richText nodes.
+ * Only hashes the visual-relevant props (style, maxWidth, wrap, variant, dim,
+ * textOverflow) to avoid the cost of iterating all keys via hashPropsShallow.
+ * The text content itself is already hashed separately.
+ */
+function hashTextProps(hash, props) {
+    const textProps = props;
+    const style = textProps.style;
+    const maxWidth = textProps.maxWidth;
+    const wrap = textProps.wrap;
+    const variant = textProps.variant;
+    const dim = textProps.dim;
+    const textOverflow = textProps.textOverflow;
+    // Common case for plain text nodes with no explicit props.
+    if (style === undefined &&
+        maxWidth === undefined &&
+        wrap === undefined &&
+        variant === undefined &&
+        dim === undefined &&
+        textOverflow === undefined) {
+        return mixHash(hash, 0x7458_7430);
+    }
+    let out = hash;
+    if (style !== undefined) {
+        out = mixHash(out, 1);
+        out = mixHash(out, hashUnknown(style));
+    }
+    if (maxWidth !== undefined) {
+        out = mixHash(out, 2);
+        out = hashPropValue(out, maxWidth);
+    }
+    if (wrap !== undefined) {
+        out = mixHash(out, 3);
+        out = hashPropValue(out, wrap);
+    }
+    if (variant !== undefined) {
+        out = mixHash(out, 4);
+        out = hashPropValue(out, variant);
+    }
+    if (dim !== undefined) {
+        out = mixHash(out, 5);
+        out = hashPropValue(out, dim);
+    }
+    if (textOverflow !== undefined) {
+        out = mixHash(out, 6);
+        out = hashPropValue(out, textOverflow);
+    }
+    return out;
+}
+export function computeRenderPacketKey(node, theme, parentStyle, rectWidth, rectHeight, focusState, pressedId, tick, cursorInfo) {
+    if (!isRenderPacketCacheable(node, cursorInfo))
+        return 0;
+    const focusBits = focusPressedBits(node, focusState, pressedId);
+    const kind = node.vnode.kind;
+    const vnodeText = node.vnode.text;
+    if ((kind === "text" || kind === "richText") && vnodeText !== undefined) {
+        const props = node.vnode.props;
+        const memo = textPacketKeyMemo.get(node);
+        if (memo !== undefined &&
+            memo.kind === kind &&
+            memo.text === vnodeText &&
+            memo.props === props &&
+            memo.theme === theme &&
+            memo.parentStyle === parentStyle &&
+            memo.rectWidth === rectWidth &&
+            memo.rectHeight === rectHeight &&
+            memo.focusBits === focusBits) {
+            return memo.key;
+        }
+    }
+    let hash = FNV_OFFSET;
+    hash = mixHash(hash, hashString(kind));
+    if (vnodeText !== undefined) {
+        hash = mixHash(hash, hashTextValue(vnodeText));
+    }
+    if (kind === "text" || kind === "richText") {
+        hash = hashTextProps(hash, node.vnode.props);
+    }
+    else {
+        hash = hashPropsShallow(hash, node.vnode.props);
+    }
+    hash = mixHash(hash, hashTheme(theme));
+    hash = mixHash(hash, hashResolvedStyle(parentStyle));
+    hash = mixHash(hash, (Math.trunc(rectWidth) & HASH_MASK_32) >>> 0);
+    hash = mixHash(hash, (Math.trunc(rectHeight) & HASH_MASK_32) >>> 0);
+    hash = mixHash(hash, focusBits);
+    if (isTickDrivenKind(node.vnode.kind)) {
+        hash = mixHash(hash, tick >>> 0);
+    }
+    const out = hash === 0 ? 1 : hash >>> 0;
+    if ((kind === "text" || kind === "richText") && vnodeText !== undefined) {
+        textPacketKeyMemo.set(node, {
+            kind,
+            text: vnodeText,
+            props: node.vnode.props,
+            theme,
+            parentStyle,
+            rectWidth,
+            rectHeight,
+            focusBits,
+            key: out,
+        });
+    }
+    return out;
+}
+export class RenderPacketRecorder {
+    target;
+    originX;
+    originY;
+    ops = [];
+    resources = [];
+    blobResourceById = new Map();
+    textRunByBlobId = new Map();
+    valid = true;
+    constructor(target, originX, originY) {
+        this.target = target;
+        this.originX = originX;
+        this.originY = originY;
+    }
+    buildPacket() {
+        if (!this.valid)
+            return null;
+        const ops = this.ops;
+        const resources = this.resources;
+        this.ops = [];
+        this.resources = [];
+        this.blobResourceById.clear();
+        this.textRunByBlobId.clear();
+        return Object.freeze({
+            ops: Object.freeze(ops),
+            resources: Object.freeze(resources),
+        });
+    }
+    localX(x) {
+        return x - this.originX;
+    }
+    localY(y) {
+        return y - this.originY;
+    }
+    invalidatePacket() {
+        this.valid = false;
+    }
+    clear() {
+        this.invalidatePacket();
+        this.target.clear();
+    }
+    clearTo(cols, rows, style) {
+        this.invalidatePacket();
+        this.target.clearTo(cols, rows, style);
+    }
+    fillRect(x, y, w, h, style) {
+        this.target.fillRect(x, y, w, h, style);
+        if (style === undefined) {
+            this.ops.push({ op: "FILL_RECT", x: this.localX(x), y: this.localY(y), w, h });
+            return;
+        }
+        this.ops.push({ op: "FILL_RECT", x: this.localX(x), y: this.localY(y), w, h, style });
+    }
+    blitRect(srcX, srcY, w, h, dstX, dstY) {
+        this.invalidatePacket();
+        this.target.blitRect(srcX, srcY, w, h, dstX, dstY);
+    }
+    drawText(x, y, text, style) {
+        this.target.drawText(x, y, text, style);
+        if (style === undefined) {
+            this.ops.push({
+                op: "DRAW_TEXT_SLICE",
+                x: this.localX(x),
+                y: this.localY(y),
+                text,
+            });
+            return;
+        }
+        this.ops.push({
+            op: "DRAW_TEXT_SLICE",
+            x: this.localX(x),
+            y: this.localY(y),
+            text,
+            style,
+        });
+    }
+    pushClip(x, y, w, h) {
+        this.target.pushClip(x, y, w, h);
+        this.ops.push({ op: "PUSH_CLIP", x: this.localX(x), y: this.localY(y), w, h });
+    }
+    popClip() {
+        this.target.popClip();
+        this.ops.push({ op: "POP_CLIP" });
+    }
+    addBlob(bytes) {
+        const blobId = this.target.addBlob(bytes);
+        if (blobId !== null) {
+            const resourceId = this.resources.length;
+            this.resources.push(bytes.slice());
+            this.blobResourceById.set(blobId, resourceId);
+        }
+        return blobId;
+    }
+    addTextRunBlob(segments) {
+        const blobId = this.target.addTextRunBlob(segments);
+        if (blobId !== null) {
+            const copied = segments.map((segment) => segment.style ? { text: segment.text, style: segment.style } : { text: segment.text });
+            this.textRunByBlobId.set(blobId, copied);
+        }
+        return blobId;
+    }
+    drawTextRun(x, y, blobIndex) {
+        this.target.drawTextRun(x, y, blobIndex);
+        const segments = this.textRunByBlobId.get(blobIndex);
+        if (!segments) {
+            this.invalidatePacket();
+            return;
+        }
+        this.ops.push({
+            op: "DRAW_TEXT_RUN",
+            x: this.localX(x),
+            y: this.localY(y),
+            segments,
+        });
+    }
+    setCursor(...args) {
+        this.invalidatePacket();
+        this.target.setCursor(...args);
+    }
+    hideCursor() {
+        this.invalidatePacket();
+        this.target.hideCursor();
+    }
+    setLink(...args) {
+        this.invalidatePacket();
+        this.target.setLink(...args);
+    }
+    drawCanvas(...args) {
+        this.target.drawCanvas(...args);
+        const [x, y, w, h, blobIndex, blitter, pxWidth, pxHeight] = args;
+        const resourceId = this.blobResourceById.get(blobIndex);
+        if (resourceId === undefined) {
+            this.invalidatePacket();
+            return;
+        }
+        const op = {
+            op: "DRAW_CANVAS",
+            x: this.localX(x),
+            y: this.localY(y),
+            w,
+            h,
+            resourceId,
+            blitter,
+        };
+        if (pxWidth !== undefined)
+            op.pxWidth = pxWidth;
+        if (pxHeight !== undefined)
+            op.pxHeight = pxHeight;
+        this.ops.push(op);
+    }
+    drawImage(...args) {
+        this.target.drawImage(...args);
+        const [x, y, w, h, blobIndex, format, protocol, zLayer, fit, imageId, pxWidth, pxHeight] = args;
+        const resourceId = this.blobResourceById.get(blobIndex);
+        if (resourceId === undefined) {
+            this.invalidatePacket();
+            return;
+        }
+        const op = {
+            op: "DRAW_IMAGE",
+            x: this.localX(x),
+            y: this.localY(y),
+            w,
+            h,
+            resourceId,
+            format,
+            protocol,
+            zLayer,
+            fit,
+            imageId,
+        };
+        if (pxWidth !== undefined)
+            op.pxWidth = pxWidth;
+        if (pxHeight !== undefined)
+            op.pxHeight = pxHeight;
+        this.ops.push(op);
+    }
+    buildInto(dst) {
+        return this.target.buildInto(dst);
+    }
+    build() {
+        return this.target.build();
+    }
+    reset() {
+        this.target.reset();
+        this.ops.length = 0;
+        this.resources.length = 0;
+        this.blobResourceById.clear();
+        this.textRunByBlobId.clear();
+        this.valid = true;
+    }
+}
+export function emitRenderPacket(builder, packet, originX, originY) {
+    let blobByResourceId = null;
+    if (packet.resources.length > 0) {
+        blobByResourceId = new Array(packet.resources.length);
+        for (let i = 0; i < packet.resources.length; i++) {
+            const resource = packet.resources[i];
+            blobByResourceId[i] = resource ? builder.addBlob(resource) : null;
+        }
+    }
+    for (const op of packet.ops) {
+        switch (op.op) {
+            case "FILL_RECT":
+                builder.fillRect(originX + op.x, originY + op.y, op.w, op.h, op.style);
+                break;
+            case "DRAW_TEXT_SLICE":
+                builder.drawText(originX + op.x, originY + op.y, op.text, op.style);
+                break;
+            case "DRAW_TEXT_RUN": {
+                const blobId = builder.addTextRunBlob(op.segments);
+                if (blobId !== null) {
+                    builder.drawTextRun(originX + op.x, originY + op.y, blobId);
+                    break;
+                }
+                let cursorX = originX + op.x;
+                const y = originY + op.y;
+                for (const segment of op.segments) {
+                    builder.drawText(cursorX, y, segment.text, segment.style);
+                    cursorX += measureTextCells(segment.text);
+                }
+                break;
+            }
+            case "PUSH_CLIP":
+                builder.pushClip(originX + op.x, originY + op.y, op.w, op.h);
+                break;
+            case "POP_CLIP":
+                builder.popClip();
+                break;
+            case "DRAW_CANVAS": {
+                const blobId = blobByResourceId?.[op.resourceId];
+                if (blobId === null || blobId === undefined)
+                    break;
+                builder.drawCanvas(originX + op.x, originY + op.y, op.w, op.h, blobId, op.blitter, op.pxWidth, op.pxHeight);
+                break;
+            }
+            case "DRAW_IMAGE": {
+                const blobId = blobByResourceId?.[op.resourceId];
+                if (blobId === null || blobId === undefined)
+                    break;
+                builder.drawImage(originX + op.x, originY + op.y, op.w, op.h, blobId, op.format, op.protocol, op.zLayer, op.fit, op.imageId, op.pxWidth, op.pxHeight);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+}
+//# sourceMappingURL=renderPackets.js.map