@deck.gl-community/infovis-layers 9.3.5 → 9.3.7

package/dist/layers/fast-text-layer/fast-text-layout.js

@@ -0,0 +1,665 @@
+// Minimal WebGL attribute text layout ported from WIP luma.gl text utilities.
+// SPDX-License-Identifier: MIT
+import { createIterable } from '@deck.gl/core';
+import { getArrowUtf8ColumnSource, getUtf8ColumnSourceRowView } from "../../utils/utf8-string-view.js";
+/**
+ * Bytes per generated glyph vertex record.
+ *
+ * The record stores `sint16x2 glyphOffsets`, `uint16x4 glyphFrames`, `sint16x4 clipRect`,
+ * and `unorm8x4 color`.
+ */
+export const FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE = Int16Array.BYTES_PER_ELEMENT * 10 + Uint8Array.BYTES_PER_ELEMENT * 4;
+/** Build a direct-buffer UTF-8 column source without copying Arrow string bytes. */
+export function buildFastTextUtf8ColumnSource(utf8Column) {
+    return getArrowUtf8ColumnSource(utf8Column);
+}
+/** Collect all renderable characters reached by a text accessor. */
+export function collectFastTextCharacterSet(props) {
+    const characterSet = new Set();
+    const { iterable, objectInfo } = createIterable(props.data);
+    for (const object of iterable) {
+        objectInfo.index++;
+        const text = resolveAccessor(props.getText, object, objectInfo) ?? '';
+        for (const character of Array.from(text)) {
+            if (character !== '\n') {
+                characterSet.add(character);
+            }
+        }
+    }
+    return characterSet;
+}
+/** Build packed per-glyph attributes for one fast text layer update. */
+export function buildFastTextGlyphData(props) {
+    const buildStartTime = performance.now();
+    const columnNormalizeStartTime = performance.now();
+    const textUtf8Column = resolveFastTextUtf8ColumnSource(props.textUtf8Column);
+    const columnNormalizeDurationMs = performance.now() - columnNormalizeStartTime;
+    if (props.textUtf8Column && !textUtf8Column) {
+        throw new Error('FastTextLayer textUtf8Column must expose Arrow Utf8 buffers');
+    }
+    if ((textUtf8Column || props.getTextUtf8) && !props.singleLine) {
+        throw new Error('FastTextLayer UTF-8 text sources require singleLine text layout');
+    }
+    const glyphData = props.singleLine
+        ? buildSingleLineGlyphData({
+            ...props,
+            textUtf8Column
+        })
+        : buildMultiLineGlyphData(props);
+    return withFastTextGlyphBuildStats(glyphData, {
+        columnNormalizeDurationMs,
+        totalDurationMs: performance.now() - buildStartTime
+    });
+}
+/** Build packed per-glyph attributes for source rows that are expected to contain no newlines. */
+export function buildSingleLineGlyphData(props) {
+    const buildStartTime = performance.now();
+    const countStartTime = performance.now();
+    const countResult = countSingleLineFastTextGlyphs(props);
+    const countDurationMs = performance.now() - countStartTime;
+    const allocateStartTime = performance.now();
+    const attributes = allocateFastTextGlyphAttributes(countResult.glyphCount);
+    const startIndices = new Uint32Array(countResult.rowCount + 1);
+    const allocateDurationMs = performance.now() - allocateStartTime;
+    const writeState = {
+        glyphIndex: 0,
+        startIndices,
+        attributes,
+        glyphRecordViews: createFastTextGlyphRecordViews(attributes.instanceGlyphData)
+    };
+    const writeTimings = createFastTextGlyphWriteTimings();
+    const byteLookup = props.textUtf8Column || props.getTextUtf8 ? buildFastTextByteGlyphLookup(props.mapping) : null;
+    const scratchUtf8View = { data: EMPTY_BYTES, start: 0, end: 0 };
+    const { iterable, objectInfo } = createIterable(props.data);
+    const writeStartTime = performance.now();
+    for (const object of iterable) {
+        objectInfo.index++;
+        startIndices[objectInfo.index] = writeState.glyphIndex;
+        if (props.textUtf8Column && byteLookup) {
+            writeSingleLineUtf8LabelGlyphs(props, props.textUtf8Column, byteLookup, scratchUtf8View, object, objectInfo, writeState, writeTimings);
+        }
+        else if (props.getTextUtf8 && byteLookup) {
+            writeSingleLineUtf8ViewLabelGlyphs(props, props.getTextUtf8, byteLookup, scratchUtf8View, object, objectInfo, writeState, writeTimings);
+        }
+        else {
+            writeSingleLineStringLabelGlyphs(props, object, objectInfo, writeState, writeTimings);
+        }
+    }
+    startIndices[countResult.rowCount] = writeState.glyphIndex;
+    const writeDurationMs = performance.now() - writeStartTime;
+    return createFastTextGlyphData(countResult, startIndices, attributes, {
+        sourceMode: props.textUtf8Column ? 'utf8-column' : props.getTextUtf8 ? 'utf8-view' : 'string',
+        layoutMode: 'single-line',
+        columnNormalizeDurationMs: 0,
+        countDurationMs,
+        allocateDurationMs,
+        writeDurationMs,
+        ...writeTimings,
+        totalDurationMs: performance.now() - buildStartTime
+    });
+}
+/** Build packed per-glyph attributes for source rows that may contain newlines. */
+export function buildMultiLineGlyphData(props) {
+    const buildStartTime = performance.now();
+    const countStartTime = performance.now();
+    const countResult = countMultiLineFastTextGlyphs(props);
+    const countDurationMs = performance.now() - countStartTime;
+    const allocateStartTime = performance.now();
+    const attributes = allocateFastTextGlyphAttributes(countResult.glyphCount);
+    const startIndices = new Uint32Array(countResult.rowCount + 1);
+    const allocateDurationMs = performance.now() - allocateStartTime;
+    const writeState = {
+        glyphIndex: 0,
+        startIndices,
+        attributes,
+        glyphRecordViews: createFastTextGlyphRecordViews(attributes.instanceGlyphData)
+    };
+    const writeTimings = createFastTextGlyphWriteTimings();
+    const { iterable, objectInfo } = createIterable(props.data);
+    const writeStartTime = performance.now();
+    for (const object of iterable) {
+        objectInfo.index++;
+        startIndices[objectInfo.index] = writeState.glyphIndex;
+        writeMultiLineLabelGlyphs(props, object, objectInfo, writeState, writeTimings);
+    }
+    startIndices[countResult.rowCount] = writeState.glyphIndex;
+    const writeDurationMs = performance.now() - writeStartTime;
+    return createFastTextGlyphData(countResult, startIndices, attributes, {
+        sourceMode: 'string',
+        layoutMode: 'multi-line',
+        columnNormalizeDurationMs: 0,
+        countDurationMs,
+        allocateDurationMs,
+        writeDurationMs,
+        ...writeTimings,
+        totalDurationMs: performance.now() - buildStartTime
+    });
+}
+/** Rewrite dynamic per-row glyph attributes while preserving generated text layout attributes. */
+export function updateFastTextDynamicGlyphAttributes(props) {
+    const updateStartTime = performance.now();
+    const glyphRecordViews = createFastTextGlyphRecordViews(props.glyphData.attributes.instanceGlyphData);
+    const { iterable, objectInfo } = createIterable(props.data);
+    let rowCount = 0;
+    let glyphCount = 0;
+    let positionAccessorDurationMs = 0;
+    let colorAccessorDurationMs = 0;
+    let clipRectAccessorDurationMs = 0;
+    let writeDurationMs = 0;
+    for (const object of iterable) {
+        objectInfo.index++;
+        rowCount++;
+        const rowGlyphStart = props.glyphData.startIndices[objectInfo.index] ?? 0;
+        const rowGlyphEnd = props.glyphData.startIndices[objectInfo.index + 1] ?? rowGlyphStart;
+        if (rowGlyphEnd <= rowGlyphStart) {
+            continue;
+        }
+        let position = DEFAULT_POSITION;
+        let color = DEFAULT_COLOR;
+        let clipRect = DEFAULT_CLIP_RECT;
+        if (props.updatePositions) {
+            const accessorStartTime = performance.now();
+            position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+            positionAccessorDurationMs += performance.now() - accessorStartTime;
+        }
+        if (props.updateColors) {
+            const accessorStartTime = performance.now();
+            color = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
+            colorAccessorDurationMs += performance.now() - accessorStartTime;
+        }
+        if (props.updateClipRects) {
+            const accessorStartTime = performance.now();
+            clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+            clipRectAccessorDurationMs += performance.now() - accessorStartTime;
+        }
+        const writeStartTime = performance.now();
+        for (let glyphIndex = rowGlyphStart; glyphIndex < rowGlyphEnd; glyphIndex += 1) {
+            if (props.updatePositions) {
+                writeFastTextGlyphPosition(props.glyphData.attributes, glyphIndex, position);
+            }
+            if (props.updateClipRects) {
+                writeFastTextGlyphClipRect(glyphRecordViews, glyphIndex, clipRect);
+            }
+            if (props.updateColors) {
+                writeFastTextGlyphColor(glyphRecordViews, glyphIndex, color);
+            }
+        }
+        writeDurationMs += performance.now() - writeStartTime;
+        glyphCount += rowGlyphEnd - rowGlyphStart;
+    }
+    return {
+        rowCount,
+        glyphCount,
+        attributeByteLength: props.glyphData.byteLength,
+        positionAccessorDurationMs,
+        colorAccessorDurationMs,
+        clipRectAccessorDurationMs,
+        writeDurationMs,
+        totalDurationMs: performance.now() - updateStartTime
+    };
+}
+const MISSING_CHARACTER_ADVANCE = 32;
+const FAST_TEXT_BYTE_LOOKUP_SIZE = 256;
+const EMPTY_BYTES = new Uint8Array();
+const DEFAULT_COLOR = [0, 0, 0, 255];
+const DEFAULT_POSITION = [0, 0, 0];
+const DEFAULT_CLIP_RECT = [0, 0, -1, -1];
+const ANCHOR_OFFSET_MULTIPLIER = {
+    start: 0,
+    middle: -0.5,
+    end: -1
+};
+const BASELINE_OFFSET_MULTIPLIER = {
+    top: 0,
+    center: -0.5,
+    bottom: -1
+};
+/** Count single-line rendered glyphs and rows before allocating fixed-size typed arrays. */
+function countSingleLineFastTextGlyphs(props) {
+    if (props.textUtf8Column) {
+        return countSingleLineUtf8FastTextGlyphs(props, props.textUtf8Column);
+    }
+    if (props.getTextUtf8) {
+        return countSingleLineUtf8ViewFastTextGlyphs(props, props.getTextUtf8);
+    }
+    return countSingleLineStringFastTextGlyphs(props);
+}
+/** Count single-line UTF-8 bytes as glyph records without decoding strings. */
+function countSingleLineUtf8FastTextGlyphs(props, textUtf8Column) {
+    let glyphCount = 0;
+    let rowCount = 0;
+    const characterSet = new Set();
+    const textView = { data: EMPTY_BYTES, start: 0, end: 0 };
+    const { iterable, objectInfo } = createIterable(props.data);
+    for (const object of iterable) {
+        objectInfo.index++;
+        rowCount++;
+        const rowIndex = resolveTextUtf8Row(props.getTextUtf8Row, object, objectInfo);
+        if (rowIndex == null || !getUtf8ColumnSourceRowView(textUtf8Column, rowIndex, textView)) {
+            continue;
+        }
+        glyphCount += textView.end - textView.start;
+    }
+    return { glyphCount, rowCount, characterSet };
+}
+/** Count single-line UTF-8 byte-view labels without decoding strings. */
+function countSingleLineUtf8ViewFastTextGlyphs(props, getTextUtf8) {
+    let glyphCount = 0;
+    let rowCount = 0;
+    const characterSet = new Set();
+    const textView = { data: EMPTY_BYTES, start: 0, end: 0 };
+    const { iterable, objectInfo } = createIterable(props.data);
+    for (const object of iterable) {
+        objectInfo.index++;
+        rowCount++;
+        if (getTextUtf8(object, textView, objectInfo)) {
+            glyphCount += Math.max(0, textView.end - textView.start);
+        }
+    }
+    return { glyphCount, rowCount, characterSet };
+}
+/** Count single-line JavaScript string code units without scanning for newline separators. */
+function countSingleLineStringFastTextGlyphs(props) {
+    let glyphCount = 0;
+    let rowCount = 0;
+    const characterSet = new Set();
+    const { iterable, objectInfo } = createIterable(props.data);
+    for (const object of iterable) {
+        objectInfo.index++;
+        rowCount++;
+        const text = resolveAccessor(props.getText, object, objectInfo) ?? '';
+        glyphCount += text.length;
+        for (let index = 0; index < text.length; index += 1) {
+            characterSet.add(text[index]);
+        }
+    }
+    return { glyphCount, rowCount, characterSet };
+}
+/** Count multiline rendered glyphs and rows before allocating fixed-size typed arrays. */
+function countMultiLineFastTextGlyphs(props) {
+    let glyphCount = 0;
+    let rowCount = 0;
+    const characterSet = new Set();
+    const { iterable, objectInfo } = createIterable(props.data);
+    for (const object of iterable) {
+        objectInfo.index++;
+        rowCount++;
+        const text = resolveAccessor(props.getText, object, objectInfo) ?? '';
+        for (const character of Array.from(text)) {
+            if (character === '\n') {
+                continue;
+            }
+            characterSet.add(character);
+            glyphCount++;
+        }
+    }
+    return { glyphCount, rowCount, characterSet };
+}
+/** Allocate all per-glyph typed arrays for one glyph count. */
+function allocateFastTextGlyphAttributes(glyphCount) {
+    return {
+        instanceGlyphData: new Uint8Array(glyphCount * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE),
+        instancePositions: new Float32Array(glyphCount * 2)
+    };
+}
+/** Build typed record views over the packed generated glyph data. */
+function createFastTextGlyphRecordViews(instanceGlyphData) {
+    return {
+        int16Values: new Int16Array(instanceGlyphData.buffer),
+        uint16Values: new Uint16Array(instanceGlyphData.buffer),
+        uint8Values: instanceGlyphData
+    };
+}
+/** Create the public glyph data wrapper around generated typed arrays. */
+function createFastTextGlyphData(countResult, startIndices, attributes, stats) {
+    const byteLength = startIndices.byteLength +
+        attributes.instanceGlyphData.byteLength +
+        attributes.instancePositions.byteLength;
+    return {
+        length: countResult.glyphCount,
+        startIndices,
+        attributes,
+        characterSet: countResult.characterSet,
+        byteLength,
+        buildStats: {
+            ...stats,
+            rowCount: countResult.rowCount,
+            glyphCount: countResult.glyphCount,
+            attributeByteLength: byteLength
+        }
+    };
+}
+function createFastTextGlyphWriteTimings() {
+    return {
+        textResolveDurationMs: 0,
+        styleAccessorDurationMs: 0,
+        layoutDurationMs: 0,
+        glyphWriteDurationMs: 0
+    };
+}
+/** Return one glyph-data object with caller-supplied timing overrides. */
+function withFastTextGlyphBuildStats(glyphData, stats) {
+    return {
+        ...glyphData,
+        buildStats: {
+            ...glyphData.buildStats,
+            ...stats
+        }
+    };
+}
+/** Write all generated glyph records for one single-line JavaScript string label row. */
+function writeSingleLineStringLabelGlyphs(props, object, objectInfo, writeState, timings) {
+    const textResolveStartTime = performance.now();
+    const text = resolveAccessor(props.getText, object, objectInfo) ?? '';
+    timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+    if (!text) {
+        return;
+    }
+    const styleAccessorStartTime = performance.now();
+    const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+    const color = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
+    const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+    timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+    const layoutStartTime = performance.now();
+    const width = getSingleLineStringWidth(text, props.mapping);
+    const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * width;
+    const rowBaselineY = getSingleLineBaselineY(props);
+    timings.layoutDurationMs += performance.now() - layoutStartTime;
+    let cursorX = 0;
+    const glyphWriteStartTime = performance.now();
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index];
+        const frame = props.mapping[character];
+        writeFastTextGlyphRecord({
+            frame,
+            lineOffsetX,
+            cursorX,
+            rowBaselineY,
+            position,
+            color,
+            clipRect,
+            writeState
+        });
+        cursorX += frame?.advance ?? MISSING_CHARACTER_ADVANCE;
+    }
+    timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+/** Write all generated glyph records for one single-line UTF-8 byte label row. */
+function writeSingleLineUtf8LabelGlyphs(props, textUtf8Column, byteLookup, textView, object, objectInfo, writeState, timings) {
+    const textResolveStartTime = performance.now();
+    const rowIndex = resolveTextUtf8Row(props.getTextUtf8Row, object, objectInfo);
+    const hasTextView = rowIndex != null && getUtf8ColumnSourceRowView(textUtf8Column, rowIndex, textView);
+    timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+    if (!hasTextView) {
+        return;
+    }
+    if (textView.end <= textView.start) {
+        return;
+    }
+    const styleAccessorStartTime = performance.now();
+    const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+    const color = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
+    const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+    timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+    const layoutStartTime = performance.now();
+    const width = getSingleLineUtf8Width(textView, byteLookup);
+    const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * width;
+    const rowBaselineY = getSingleLineBaselineY(props);
+    timings.layoutDurationMs += performance.now() - layoutStartTime;
+    let cursorX = 0;
+    const glyphWriteStartTime = performance.now();
+    for (let byteIndex = textView.start; byteIndex < textView.end; byteIndex += 1) {
+        const frame = byteLookup[textView.data[byteIndex] ?? -1];
+        writeFastTextGlyphRecord({
+            frame,
+            lineOffsetX,
+            cursorX,
+            rowBaselineY,
+            position,
+            color,
+            clipRect,
+            writeState
+        });
+        cursorX += frame?.advance ?? MISSING_CHARACTER_ADVANCE;
+    }
+    timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+/** Write all generated glyph records for one accessor-provided UTF-8 byte label row. */
+function writeSingleLineUtf8ViewLabelGlyphs(props, getTextUtf8, byteLookup, textView, object, objectInfo, writeState, timings) {
+    const textResolveStartTime = performance.now();
+    const hasTextView = getTextUtf8(object, textView, objectInfo);
+    timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+    if (!hasTextView || textView.end <= textView.start) {
+        return;
+    }
+    const styleAccessorStartTime = performance.now();
+    const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+    const color = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
+    const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+    timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+    const layoutStartTime = performance.now();
+    const width = getSingleLineUtf8Width(textView, byteLookup);
+    const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * width;
+    const rowBaselineY = getSingleLineBaselineY(props);
+    timings.layoutDurationMs += performance.now() - layoutStartTime;
+    let cursorX = 0;
+    const glyphWriteStartTime = performance.now();
+    for (let byteIndex = textView.start; byteIndex < textView.end; byteIndex += 1) {
+        const frame = byteLookup[textView.data[byteIndex] ?? -1];
+        writeFastTextGlyphRecord({
+            frame,
+            lineOffsetX,
+            cursorX,
+            rowBaselineY,
+            position,
+            color,
+            clipRect,
+            writeState
+        });
+        cursorX += frame?.advance ?? MISSING_CHARACTER_ADVANCE;
+    }
+    timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+/** Write all generated glyph records for one multiline source label row. */
+function writeMultiLineLabelGlyphs(props, object, objectInfo, writeState, timings) {
+    const textResolveStartTime = performance.now();
+    const text = resolveAccessor(props.getText, object, objectInfo) ?? '';
+    timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+    if (!text) {
+        return;
+    }
+    const styleAccessorStartTime = performance.now();
+    const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+    const color = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
+    const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+    timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+    const layoutStartTime = performance.now();
+    const lines = buildFastTextLineLayouts(text, props.mapping);
+    const lineHeightPixels = props.lineHeight * props.fontSize;
+    const labelHeight = lines.length * lineHeightPixels;
+    const blockOffsetY = BASELINE_OFFSET_MULTIPLIER[props.alignmentBaseline] * labelHeight;
+    timings.layoutDurationMs += performance.now() - layoutStartTime;
+    const glyphWriteStartTime = performance.now();
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * line.width;
+        const rowBaselineY = blockOffsetY + props.baselineOffset + lineHeightPixels / 2 + lineIndex * lineHeightPixels;
+        let cursorX = 0;
+        for (const character of line.characters) {
+            const frame = props.mapping[character];
+            writeFastTextGlyphRecord({
+                frame,
+                lineOffsetX,
+                cursorX,
+                rowBaselineY,
+                position,
+                color,
+                clipRect,
+                writeState
+            });
+            cursorX += frame?.advance ?? MISSING_CHARACTER_ADVANCE;
+        }
+    }
+    timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+/** Convert one source text into line widths and per-line characters. */
+function buildFastTextLineLayouts(text, mapping) {
+    const lines = [];
+    let currentCharacters = [];
+    let currentWidth = 0;
+    let currentGlyphCount = 0;
+    for (const character of Array.from(text)) {
+        if (character === '\n') {
+            lines.push({
+                characters: currentCharacters,
+                width: currentWidth,
+                glyphCount: currentGlyphCount
+            });
+            currentCharacters = [];
+            currentWidth = 0;
+            currentGlyphCount = 0;
+            continue;
+        }
+        const frame = mapping[character];
+        currentCharacters.push(character);
+        currentWidth += frame?.advance ?? MISSING_CHARACTER_ADVANCE;
+        if (frame) {
+            currentGlyphCount++;
+        }
+    }
+    lines.push({
+        characters: currentCharacters,
+        width: currentWidth,
+        glyphCount: currentGlyphCount
+    });
+    return lines;
+}
+/** Resolve a caller-supplied Arrow vector or pre-normalized source into a direct UTF-8 source. */
+function resolveFastTextUtf8ColumnSource(textUtf8Column) {
+    if (!textUtf8Column) {
+        return null;
+    }
+    return isFastTextUtf8ColumnSource(textUtf8Column)
+        ? textUtf8Column
+        : buildFastTextUtf8ColumnSource(textUtf8Column);
+}
+/** Return whether an object already has the normalized UTF-8 column-source shape. */
+function isFastTextUtf8ColumnSource(textUtf8Column) {
+    return 'rowCount' in textUtf8Column && 'chunks' in textUtf8Column;
+}
+/** Build an ASCII byte-to-glyph lookup from the string-keyed atlas mapping. */
+function buildFastTextByteGlyphLookup(mapping) {
+    const lookup = new Array(FAST_TEXT_BYTE_LOOKUP_SIZE);
+    for (let byte = 0; byte < 128; byte += 1) {
+        lookup[byte] = mapping[String.fromCharCode(byte)];
+    }
+    return lookup;
+}
+/** Resolve the source-row index inside a UTF-8 column. */
+function resolveTextUtf8Row(getTextUtf8Row, object, objectInfo) {
+    return getTextUtf8Row === undefined
+        ? objectInfo.index
+        : resolveAccessor(getTextUtf8Row, object, objectInfo);
+}
+/** Compute one single-line string label width without looking for newline separators. */
+function getSingleLineStringWidth(text, mapping) {
+    let width = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        width += mapping[text[index]]?.advance ?? MISSING_CHARACTER_ADVANCE;
+    }
+    return width;
+}
+/** Compute one single-line UTF-8 byte label width without decoding bytes to characters. */
+function getSingleLineUtf8Width(textView, byteLookup) {
+    let width = 0;
+    for (let byteIndex = textView.start; byteIndex < textView.end; byteIndex += 1) {
+        width += byteLookup[textView.data[byteIndex] ?? -1]?.advance ?? MISSING_CHARACTER_ADVANCE;
+    }
+    return width;
+}
+/** Compute the baseline Y position for a one-line label. */
+function getSingleLineBaselineY(props) {
+    const lineHeightPixels = props.lineHeight * props.fontSize;
+    const blockOffsetY = BASELINE_OFFSET_MULTIPLIER[props.alignmentBaseline] * lineHeightPixels;
+    return blockOffsetY + props.baselineOffset + lineHeightPixels / 2;
+}
+/** Write one packed glyph record into the generated attribute arrays. */
+function writeFastTextGlyphRecord(params) {
+    const frame = params.frame;
+    const glyphIndex = params.writeState.glyphIndex;
+    const recordInt16Index = (glyphIndex * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE) / Int16Array.BYTES_PER_ELEMENT;
+    const glyphX = params.lineOffsetX + params.cursorX + (frame?.anchorX ?? 0) - (frame?.width ?? 0) / 2;
+    const glyphY = params.rowBaselineY - (frame?.anchorY ?? 0);
+    const writeState = params.writeState;
+    writeFastTextGlyphPosition(writeState.attributes, glyphIndex, params.position);
+    writeState.glyphRecordViews.int16Values[recordInt16Index] = toInt16(glyphX);
+    writeState.glyphRecordViews.int16Values[recordInt16Index + 1] = toInt16(glyphY);
+    writeState.glyphRecordViews.uint16Values[recordInt16Index + 2] = toUint16(frame?.x ?? 0);
+    writeState.glyphRecordViews.uint16Values[recordInt16Index + 3] = toUint16(frame?.y ?? 0);
+    writeState.glyphRecordViews.uint16Values[recordInt16Index + 4] = toUint16(frame?.width ?? 0);
+    writeState.glyphRecordViews.uint16Values[recordInt16Index + 5] = toUint16(frame?.height ?? 0);
+    writeFastTextGlyphClipRect(writeState.glyphRecordViews, glyphIndex, params.clipRect);
+    writeFastTextGlyphColor(writeState.glyphRecordViews, glyphIndex, params.color);
+    writeState.glyphIndex++;
+}
+/** Write one source anchor position into the repeated per-glyph position array. */
+function writeFastTextGlyphPosition(attributes, glyphIndex, position) {
+    const positionOffset = glyphIndex * 2;
+    attributes.instancePositions[positionOffset] = position[0] ?? 0;
+    attributes.instancePositions[positionOffset + 1] = position[1] ?? 0;
+}
+/** Write one source clip rectangle into the packed generated glyph record. */
+function writeFastTextGlyphClipRect(glyphRecordViews, glyphIndex, clipRect) {
+    const recordInt16Index = (glyphIndex * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE) / Int16Array.BYTES_PER_ELEMENT;
+    glyphRecordViews.int16Values[recordInt16Index + 6] = toInt16(clipRect[0] ?? 0);
+    glyphRecordViews.int16Values[recordInt16Index + 7] = toInt16(clipRect[1] ?? 0);
+    glyphRecordViews.int16Values[recordInt16Index + 8] = toInt16ClipDimension(clipRect[2] ?? -1);
+    glyphRecordViews.int16Values[recordInt16Index + 9] = toInt16ClipDimension(clipRect[3] ?? -1);
+}
+/** Write one source color into the packed generated glyph record. */
+function writeFastTextGlyphColor(glyphRecordViews, glyphIndex, color) {
+    const recordByteIndex = glyphIndex * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE;
+    writeColor(glyphRecordViews.uint8Values, recordByteIndex + Int16Array.BYTES_PER_ELEMENT * 10, color);
+}
+/** Resolve deck accessors that may be constants or functions. */
+function resolveAccessor(accessor, object, objectInfo) {
+    return typeof accessor === 'function'
+        ? accessor(object, objectInfo)
+        : accessor;
+}
+/** Write one deck color into a byte array with a default opaque alpha. */
+function writeColor(target, offset, color) {
+    target[offset] = clampByte(color[0] ?? DEFAULT_COLOR[0]);
+    target[offset + 1] = clampByte(color[1] ?? DEFAULT_COLOR[1]);
+    target[offset + 2] = clampByte(color[2] ?? DEFAULT_COLOR[2]);
+    target[offset + 3] = clampByte(color[3] ?? DEFAULT_COLOR[3]);
+}
+/** Clamp one color channel into the unsigned byte range. */
+function clampByte(value) {
+    return Math.max(0, Math.min(255, Math.round(value)));
+}
+/** Round and validate one value for the signed 16-bit generated attribute record. */
+function toInt16(value) {
+    const integerValue = Math.round(value);
+    if (integerValue < -32768 || integerValue > 32767) {
+        throw new Error(`FastTextLayer value ${value} is outside the signed 16-bit range`);
+    }
+    return integerValue;
+}
+/** Round one clip dimension while preserving positive non-zero values. */
+function toInt16ClipDimension(value) {
+    const integerValue = value > 0 ? Math.max(1, Math.round(value)) : Math.round(value);
+    if (integerValue < -32768 || integerValue > 32767) {
+        throw new Error(`FastTextLayer value ${value} is outside the signed 16-bit range`);
+    }
+    return integerValue;
+}
+/** Round and validate one atlas frame value for the unsigned 16-bit generated attribute record. */
+function toUint16(value) {
+    const integerValue = Math.round(value);
+    if (integerValue < 0 || integerValue > 65535) {
+        throw new Error(`FastTextLayer glyph frame value ${value} is outside the unsigned 16-bit range`);
+    }
+    return integerValue;
+}
+//# sourceMappingURL=fast-text-layout.js.map