@llc3233149/core 0.9.0

package/dist/kiwi/kiwi-convert.js

@@ -0,0 +1,678 @@
+import { normalizeColor } from '../color.js';
+import { DEFAULT_FONT_FAMILY, DEFAULT_STROKE_MITER_LIMIT } from '../constants.js';
+import { styleToWeight } from '../fonts.js';
+import { decodeVectorNetworkBlob } from '../vector.js';
+export function guidToString(guid) {
+    return `${guid.sessionID}:${guid.localID}`;
+}
+export function stringToGuid(str) {
+    const [session, local] = str.split(':');
+    return { sessionID: parseInt(session, 10), localID: parseInt(local, 10) };
+}
+export const VARIABLE_BINDING_FIELDS = {
+    cornerRadius: 'CORNER_RADIUS',
+    topLeftRadius: 'RECTANGLE_TOP_LEFT_CORNER_RADIUS',
+    topRightRadius: 'RECTANGLE_TOP_RIGHT_CORNER_RADIUS',
+    bottomLeftRadius: 'RECTANGLE_BOTTOM_LEFT_CORNER_RADIUS',
+    bottomRightRadius: 'RECTANGLE_BOTTOM_RIGHT_CORNER_RADIUS',
+    strokeWeight: 'STROKE_WEIGHT',
+    itemSpacing: 'STACK_SPACING',
+    paddingLeft: 'STACK_PADDING_LEFT',
+    paddingTop: 'STACK_PADDING_TOP',
+    paddingRight: 'STACK_PADDING_RIGHT',
+    paddingBottom: 'STACK_PADDING_BOTTOM',
+    counterAxisSpacing: 'STACK_COUNTER_SPACING',
+    visible: 'VISIBLE',
+    opacity: 'OPACITY',
+    width: 'WIDTH',
+    height: 'HEIGHT',
+    fontSize: 'FONT_SIZE',
+    letterSpacing: 'LETTER_SPACING',
+    lineHeight: 'LINE_HEIGHT'
+};
+export const VARIABLE_BINDING_FIELDS_INVERSE = Object.fromEntries(Object.entries(VARIABLE_BINDING_FIELDS).map(([k, v]) => [v, k]));
+const convertColor = normalizeColor;
+function imageHashToString(hash) {
+    const bytes = Object.keys(hash)
+        .sort((a, b) => Number(a) - Number(b))
+        .map((k) => hash[Number(k)]);
+    return bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+function convertGradientTransform(t) {
+    if (!t)
+        return undefined;
+    return { m00: t.m00, m01: t.m01, m02: t.m02, m10: t.m10, m11: t.m11, m12: t.m12 };
+}
+export function convertFills(paints) {
+    if (!paints)
+        return [];
+    return paints.map((p) => {
+        const base = {
+            type: p.type,
+            color: convertColor(p.color),
+            opacity: p.opacity ?? 1,
+            visible: p.visible ?? true,
+            blendMode: (p.blendMode ?? 'NORMAL')
+        };
+        if (p.type.startsWith('GRADIENT') && p.stops) {
+            base.gradientStops = p.stops.map((s) => ({
+                color: convertColor(s.color),
+                position: s.position
+            }));
+            if (p.transform) {
+                base.gradientTransform = convertGradientTransform(p.transform);
+            }
+        }
+        if (p.type === 'IMAGE') {
+            if (p.image && typeof p.image === 'object') {
+                const img = p.image;
+                if (typeof img.hash === 'object') {
+                    base.imageHash = imageHashToString(img.hash);
+                }
+                else if (typeof img.hash === 'string') {
+                    base.imageHash = img.hash;
+                }
+            }
+            base.imageScaleMode = (p.imageScaleMode ?? 'FILL');
+            if (p.transform) {
+                base.imageTransform = convertGradientTransform(p.transform);
+            }
+        }
+        return base;
+    });
+}
+function convertStrokes(paints, weight, align, cap, join, dashPattern) {
+    if (!paints)
+        return [];
+    return paints.map((p) => ({
+        color: convertColor(p.color),
+        weight: weight ?? 1,
+        opacity: p.opacity ?? 1,
+        visible: p.visible ?? true,
+        align: (align === 'INSIDE'
+            ? 'INSIDE'
+            : (align === 'OUTSIDE'
+                ? 'OUTSIDE'
+                : 'CENTER')),
+        cap: (cap ?? 'NONE'),
+        join: (join ?? 'MITER'),
+        dashPattern: dashPattern ?? []
+    }));
+}
+function convertEffects(effects) {
+    if (!effects)
+        return [];
+    return effects.map((e) => ({
+        type: e.type,
+        color: convertColor(e.color),
+        offset: e.offset ?? { x: 0, y: 0 },
+        radius: e.radius ?? 0,
+        spread: e.spread ?? 0,
+        visible: e.visible ?? true,
+        blendMode: (e.blendMode ?? 'NORMAL')
+    }));
+}
+const NODE_TYPE_MAP = {
+    DOCUMENT: 'DOCUMENT',
+    VARIABLE: 'VARIABLE',
+    CANVAS: 'CANVAS',
+    FRAME: 'FRAME',
+    RECTANGLE: 'RECTANGLE',
+    ROUNDED_RECTANGLE: 'ROUNDED_RECTANGLE',
+    ELLIPSE: 'ELLIPSE',
+    TEXT: 'TEXT',
+    LINE: 'LINE',
+    STAR: 'STAR',
+    REGULAR_POLYGON: 'POLYGON',
+    VECTOR: 'VECTOR',
+    BOOLEAN_OPERATION: 'VECTOR',
+    GROUP: 'GROUP',
+    SECTION: 'SECTION',
+    COMPONENT: 'COMPONENT',
+    COMPONENT_SET: 'COMPONENT_SET',
+    INSTANCE: 'INSTANCE',
+    SYMBOL: 'COMPONENT',
+    CONNECTOR: 'CONNECTOR',
+    SHAPE_WITH_TEXT: 'SHAPE_WITH_TEXT'
+};
+function mapNodeType(type) {
+    if (type)
+        return NODE_TYPE_MAP[type] ?? 'RECTANGLE';
+    return 'RECTANGLE';
+}
+function mapStackMode(mode) {
+    switch (mode) {
+        case 'HORIZONTAL':
+            return 'HORIZONTAL';
+        case 'VERTICAL':
+            return 'VERTICAL';
+        default:
+            return 'NONE';
+    }
+}
+function mapStackSizing(sizing) {
+    switch (sizing) {
+        case 'RESIZE_TO_FIT':
+        case 'RESIZE_TO_FIT_WITH_IMPLICIT_SIZE':
+            return 'HUG';
+        case 'FILL':
+            return 'FILL';
+        default:
+            return 'FIXED';
+    }
+}
+function mapStackJustify(justify) {
+    switch (justify) {
+        case 'CENTER':
+            return 'CENTER';
+        case 'MAX':
+            return 'MAX';
+        case 'SPACE_BETWEEN':
+            return 'SPACE_BETWEEN';
+        default:
+            return 'MIN';
+    }
+}
+function mapStackCounterAlign(align) {
+    switch (align) {
+        case 'CENTER':
+            return 'CENTER';
+        case 'MAX':
+            return 'MAX';
+        case 'STRETCH':
+            return 'STRETCH';
+        case 'BASELINE':
+            return 'BASELINE';
+        default:
+            return 'MIN';
+    }
+}
+function mapAlignSelf(align) {
+    switch (align) {
+        case 'MIN':
+            return 'MIN';
+        case 'CENTER':
+            return 'CENTER';
+        case 'MAX':
+            return 'MAX';
+        case 'STRETCH':
+            return 'STRETCH';
+        case 'BASELINE':
+            return 'BASELINE';
+        default:
+            return 'AUTO';
+    }
+}
+function mapConstraint(c) {
+    switch (c) {
+        case 'CENTER':
+            return 'CENTER';
+        case 'MAX':
+            return 'MAX';
+        case 'STRETCH':
+            return 'STRETCH';
+        case 'SCALE':
+            return 'SCALE';
+        default:
+            return 'MIN';
+    }
+}
+function mapTextDecoration(d) {
+    switch (d) {
+        case 'UNDERLINE':
+            return 'UNDERLINE';
+        case 'STRIKETHROUGH':
+            return 'STRIKETHROUGH';
+        default:
+            return 'NONE';
+    }
+}
+function convertLineHeight(lh, fontSize) {
+    if (!lh)
+        return null;
+    if (lh.units === 'PIXELS')
+        return lh.value;
+    if (lh.units === 'PERCENT')
+        return (lh.value / 100) * (fontSize ?? 14);
+    if (lh.units === 'RAW')
+        return lh.value * (fontSize ?? 14);
+    return null;
+}
+function convertLetterSpacing(ls, fontSize) {
+    if (!ls)
+        return 0;
+    if (ls.units === 'PIXELS')
+        return ls.value;
+    if (ls.units === 'PERCENT')
+        return (ls.value / 100) * (fontSize ?? 14);
+    return ls.value;
+}
+function mapArcData(data) {
+    if (!data)
+        return null;
+    return {
+        startingAngle: data.startingAngle ?? 0,
+        endingAngle: data.endingAngle ?? 2 * Math.PI,
+        innerRadius: data.innerRadius ?? 0
+    };
+}
+function convertStyleOverride(override, fallbackFontSize) {
+    const style = {};
+    if (override.fontName) {
+        style.fontFamily = override.fontName.family;
+        style.fontWeight = styleToWeight(override.fontName.style);
+        style.italic = override.fontName.style.toLowerCase().includes('italic');
+    }
+    if (override.fontSize !== undefined)
+        style.fontSize = override.fontSize;
+    if (override.letterSpacing) {
+        style.letterSpacing = convertLetterSpacing(override.letterSpacing, override.fontSize ?? fallbackFontSize);
+    }
+    if (override.lineHeight) {
+        const lh = convertLineHeight(override.lineHeight, override.fontSize ?? fallbackFontSize);
+        if (lh != null)
+            style.lineHeight = lh;
+    }
+    const deco = override.textDecoration;
+    if (deco)
+        style.textDecoration = mapTextDecoration(deco);
+    return style;
+}
+function buildStyleMap(table, fallbackFontSize) {
+    const styleMap = new Map();
+    for (const override of table) {
+        const id = override.styleID;
+        if (id === undefined)
+            continue;
+        const style = convertStyleOverride(override, fallbackFontSize);
+        if (Object.keys(style).length > 0)
+            styleMap.set(id, style);
+    }
+    return styleMap;
+}
+function collectStyleRuns(ids, styleMap) {
+    const runs = [];
+    let currentId = ids[0];
+    let start = 0;
+    for (let i = 1; i <= ids.length; i++) {
+        if (i === ids.length || ids[i] !== currentId) {
+            if (currentId !== 0) {
+                const style = styleMap.get(currentId);
+                if (style)
+                    runs.push({ start, length: i - start, style });
+            }
+            if (i < ids.length) {
+                currentId = ids[i];
+                start = i;
+            }
+        }
+    }
+    return runs;
+}
+function importStyleRuns(nc) {
+    const td = nc.textData;
+    if (!td?.characterStyleIDs || !td.styleOverrideTable)
+        return [];
+    const ids = td.characterStyleIDs;
+    if (ids.length === 0 || td.styleOverrideTable.length === 0)
+        return [];
+    const styleMap = buildStyleMap(td.styleOverrideTable, nc.fontSize);
+    if (styleMap.size === 0)
+        return [];
+    return collectStyleRuns(ids, styleMap);
+}
+function resolveVectorNetwork(nc, blobs) {
+    const vectorData = nc.vectorData;
+    if (vectorData?.vectorNetworkBlob === undefined)
+        return null;
+    const idx = vectorData.vectorNetworkBlob;
+    if (idx < 0 || idx >= blobs.length)
+        return null;
+    try {
+        const network = decodeVectorNetworkBlob(blobs[idx], vectorData.styleOverrideTable);
+        const ns = vectorData.normalizedSize;
+        const nodeW = nc.size?.x ?? 0;
+        const nodeH = nc.size?.y ?? 0;
+        if (ns && nodeW > 0 && nodeH > 0 && (ns.x !== nodeW || ns.y !== nodeH)) {
+            const sx = nodeW / ns.x;
+            const sy = nodeH / ns.y;
+            for (const v of network.vertices) {
+                v.x *= sx;
+                v.y *= sy;
+            }
+            for (const seg of network.segments) {
+                seg.tangentStart = { x: seg.tangentStart.x * sx, y: seg.tangentStart.y * sy };
+                seg.tangentEnd = { x: seg.tangentEnd.x * sx, y: seg.tangentEnd.y * sy };
+            }
+        }
+        return network;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveGeometryPaths(paths, blobs) {
+    if (!paths || paths.length === 0)
+        return [];
+    const result = [];
+    for (const p of paths) {
+        if (p.commandsBlob === undefined || p.commandsBlob < 0 || p.commandsBlob >= blobs.length)
+            continue;
+        const blob = blobs[p.commandsBlob];
+        if (blob.length === 0)
+            continue;
+        result.push({
+            windingRule: (p.windingRule === 'EVENODD' ? 'EVENODD' : 'NONZERO'),
+            commandsBlob: blob
+        });
+    }
+    return result;
+}
+function extractBoundVariables(nc) {
+    const bindings = {};
+    nc.fillPaints?.forEach((paint, i) => {
+        if (paint.colorVariableBinding) {
+            bindings[`fills/${i}/color`] = guidToString(paint.colorVariableBinding.variableID);
+        }
+    });
+    nc.strokePaints?.forEach((paint, i) => {
+        if (paint.colorVariableBinding) {
+            bindings[`strokes/${i}/color`] = guidToString(paint.colorVariableBinding.variableID);
+        }
+    });
+    return bindings;
+}
+function convertTransformProps(nc) {
+    const x = nc.transform?.m02 ?? 0;
+    const y = nc.transform?.m12 ?? 0;
+    const width = nc.size?.x ?? 100;
+    const height = nc.size?.y ?? 100;
+    let rotation = 0;
+    let flipX = false;
+    if (nc.transform) {
+        const det = nc.transform.m00 * nc.transform.m11 - nc.transform.m01 * nc.transform.m10;
+        if (det < 0)
+            flipX = true;
+        const sx = flipX ? -1 : 1;
+        rotation = Math.atan2(nc.transform.m10 * sx, nc.transform.m00 * sx) * (180 / Math.PI);
+    }
+    return { x, y, width, height, rotation, flipX, flipY: false };
+}
+function convertCornerProps(nc) {
+    return {
+        cornerRadius: nc.cornerRadius ?? 0,
+        topLeftRadius: nc.rectangleTopLeftCornerRadius ?? nc.cornerRadius ?? 0,
+        topRightRadius: nc.rectangleTopRightCornerRadius ?? nc.cornerRadius ?? 0,
+        bottomRightRadius: nc.rectangleBottomRightCornerRadius ?? nc.cornerRadius ?? 0,
+        bottomLeftRadius: nc.rectangleBottomLeftCornerRadius ?? nc.cornerRadius ?? 0,
+        independentCorners: nc.rectangleCornerRadiiIndependent ?? false,
+        cornerSmoothing: nc.cornerSmoothing ?? 0
+    };
+}
+function convertTextProps(nc) {
+    return {
+        text: nc.textData?.characters ?? '',
+        fontSize: nc.fontSize ?? 14,
+        fontFamily: nc.fontName?.family ?? DEFAULT_FONT_FAMILY,
+        fontWeight: styleToWeight(nc.fontName?.style ?? ''),
+        italic: nc.fontName?.style.toLowerCase().includes('italic') ?? false,
+        textAlignHorizontal: (nc.textAlignHorizontal ?? 'LEFT'),
+        textAlignVertical: (nc.textAlignVertical ?? 'TOP'),
+        textAutoResize: (nc.textAutoResize ?? 'NONE'),
+        textCase: (nc.textCase ?? 'ORIGINAL'),
+        textDecoration: mapTextDecoration(nc.textDecoration),
+        lineHeight: convertLineHeight(nc.lineHeight, nc.fontSize),
+        letterSpacing: convertLetterSpacing(nc.letterSpacing, nc.fontSize),
+        maxLines: (nc.maxLines ?? null),
+        styleRuns: importStyleRuns(nc),
+        textTruncation: nc.textTruncation === 'ENDING' ? 'ENDING' : 'DISABLED'
+    };
+}
+function convertLayoutPadding(nc) {
+    return {
+        paddingTop: nc.stackVerticalPadding ?? nc.stackPadding ?? 0,
+        paddingBottom: nc.stackPaddingBottom ?? nc.stackVerticalPadding ?? nc.stackPadding ?? 0,
+        paddingLeft: nc.stackHorizontalPadding ?? nc.stackPadding ?? 0,
+        paddingRight: nc.stackPaddingRight ?? nc.stackHorizontalPadding ?? nc.stackPadding ?? 0
+    };
+}
+function convertLayoutProps(nc) {
+    return {
+        layoutMode: mapStackMode(nc.stackMode),
+        itemSpacing: nc.stackSpacing ?? 0,
+        ...convertLayoutPadding(nc),
+        primaryAxisSizing: mapStackSizing(nc.stackPrimarySizing),
+        counterAxisSizing: mapStackSizing(nc.stackCounterSizing),
+        primaryAxisAlign: mapStackJustify(nc.stackPrimaryAlignItems ?? nc.stackJustify),
+        counterAxisAlign: mapStackCounterAlign(nc.stackCounterAlignItems ?? nc.stackCounterAlign),
+        layoutWrap: nc.stackWrap === 'WRAP' ? 'WRAP' : 'NO_WRAP',
+        counterAxisSpacing: nc.stackCounterSpacing ?? 0,
+        layoutPositioning: nc.stackPositioning === 'ABSOLUTE' ? 'ABSOLUTE' : 'AUTO',
+        layoutGrow: nc.stackChildPrimaryGrow ?? 0,
+        layoutAlignSelf: mapAlignSelf(nc.stackChildAlignSelf),
+        counterAxisAlignContent: nc.stackCounterAlignContent === 'SPACE_BETWEEN' ? 'SPACE_BETWEEN' : 'AUTO',
+        itemReverseZIndex: (nc.stackReverseZIndex ?? false),
+        strokesIncludedInLayout: (nc.strokesIncludedInLayout ?? false)
+    };
+}
+function convertVectorAndStrokeProps(nc, blobs) {
+    return {
+        vectorNetwork: resolveVectorNetwork(nc, blobs),
+        fillGeometry: resolveGeometryPaths(nc.fillGeometry, blobs),
+        strokeGeometry: resolveGeometryPaths(nc.strokeGeometry, blobs),
+        arcData: mapArcData(nc.arcData),
+        strokeCap: (nc.strokeCap ?? 'NONE'),
+        strokeJoin: (nc.strokeJoin ?? 'MITER'),
+        dashPattern: nc.dashPattern ?? [],
+        borderTopWeight: (nc.borderTopWeight ?? 0),
+        borderRightWeight: (nc.borderRightWeight ?? 0),
+        borderBottomWeight: (nc.borderBottomWeight ?? 0),
+        borderLeftWeight: (nc.borderLeftWeight ?? 0),
+        independentStrokeWeights: (nc.borderStrokeWeightsIndependent ?? false),
+        strokeMiterLimit: DEFAULT_STROKE_MITER_LIMIT
+    };
+}
+export function nodeChangeToProps(nc, blobs) {
+    let nodeType = mapNodeType(nc.type);
+    if (nodeType === 'FRAME' && isComponentSet(nc))
+        nodeType = 'COMPONENT_SET';
+    return {
+        nodeType,
+        name: nc.name ?? nodeType,
+        ...convertTransformProps(nc),
+        opacity: nc.opacity ?? 1,
+        visible: nc.visible ?? true,
+        locked: nc.locked ?? false,
+        blendMode: nc.blendMode ?? 'PASS_THROUGH',
+        fills: convertFills(nc.fillPaints),
+        strokes: convertStrokes(nc.strokePaints, nc.strokeWeight, nc.strokeAlign, nc.strokeCap, nc.strokeJoin, nc.dashPattern ?? []),
+        effects: convertEffects(nc.effects),
+        ...convertCornerProps(nc),
+        ...convertTextProps(nc),
+        horizontalConstraint: mapConstraint(nc.horizontalConstraint),
+        verticalConstraint: mapConstraint(nc.verticalConstraint),
+        ...convertLayoutProps(nc),
+        ...convertVectorAndStrokeProps(nc, blobs),
+        minWidth: (nc.minWidth ?? null),
+        maxWidth: (nc.maxWidth ?? null),
+        minHeight: (nc.minHeight ?? null),
+        maxHeight: (nc.maxHeight ?? null),
+        isMask: (nc.isMask ?? false),
+        maskType: (nc.maskType ?? 'ALPHA'),
+        expanded: true,
+        autoRename: (nc.autoRename ?? true),
+        boundVariables: extractBoundVariables(nc),
+        clipsContent: nc.frameMaskDisabled === false,
+        componentId: extractSymbolId(nc)
+    };
+}
+function isComponentSet(nc) {
+    const defs = nc.componentPropDefs;
+    if (!defs?.length)
+        return false;
+    return defs.some((d) => d.type === 'VARIANT');
+}
+export function sortChildren(children, parentNc, nodeMap) {
+    const stackMode = parentNc.stackMode;
+    if (stackMode === 'HORIZONTAL' || stackMode === 'VERTICAL') {
+        const axis = stackMode === 'HORIZONTAL' ? 'm02' : 'm12';
+        children.sort((a, b) => {
+            const aT = nodeMap.get(a)?.transform?.[axis] ?? 0;
+            const bT = nodeMap.get(b)?.transform?.[axis] ?? 0;
+            return aT - bT;
+        });
+    }
+    else {
+        children.sort((a, b) => {
+            const aPos = nodeMap.get(a)?.parentIndex?.position ?? '';
+            const bPos = nodeMap.get(b)?.parentIndex?.position ?? '';
+            return aPos < bPos ? -1 : (aPos > bPos ? 1 : 0);
+        });
+    }
+}
+function extractSymbolId(nc) {
+    const sd = nc.symbolData;
+    if (!sd?.symbolID)
+        return '';
+    return guidToString(sd.symbolID);
+}
+function applyOverridePaints(ov, updates) {
+    if (ov.textData != null) {
+        const td = ov.textData;
+        if (td.characters != null)
+            updates.text = td.characters;
+        const runs = importStyleRuns(ov);
+        if (runs.length > 0)
+            updates.styleRuns = runs;
+    }
+    if (ov.fillPaints != null)
+        updates.fills = convertFills(ov.fillPaints);
+    if (ov.strokePaints != null)
+        updates.strokes = convertStrokes(ov.strokePaints, ov.strokeWeight, ov.strokeAlign);
+    if (ov.effects != null)
+        updates.effects = convertEffects(ov.effects);
+    if (ov.visible != null)
+        updates.visible = ov.visible;
+    if (ov.opacity != null)
+        updates.opacity = ov.opacity;
+    if (ov.name != null)
+        updates.name = ov.name;
+    if (ov.locked != null)
+        updates.locked = ov.locked;
+}
+function applyOverrideGeometry(ov, updates) {
+    if (ov.size != null) {
+        const sz = ov.size;
+        if (sz.x != null)
+            updates.width = sz.x;
+        if (sz.y != null)
+            updates.height = sz.y;
+    }
+    if (ov.cornerRadius != null)
+        updates.cornerRadius = ov.cornerRadius;
+    if (ov.rectangleTopLeftCornerRadius != null)
+        updates.topLeftRadius = ov.rectangleTopLeftCornerRadius;
+    if (ov.rectangleTopRightCornerRadius != null)
+        updates.topRightRadius = ov.rectangleTopRightCornerRadius;
+    if (ov.rectangleBottomRightCornerRadius != null)
+        updates.bottomRightRadius = ov.rectangleBottomRightCornerRadius;
+    if (ov.rectangleBottomLeftCornerRadius != null)
+        updates.bottomLeftRadius = ov.rectangleBottomLeftCornerRadius;
+    if (ov.rectangleCornerRadiiIndependent != null)
+        updates.independentCorners = ov.rectangleCornerRadiiIndependent;
+    if (ov.arcData != null)
+        updates.arcData = mapArcData(ov.arcData);
+    if (ov.frameMaskDisabled != null)
+        updates.clipsContent = ov.frameMaskDisabled === false;
+}
+function applyOverrideLayout(ov, updates) {
+    if (ov.stackSpacing != null)
+        updates.itemSpacing = ov.stackSpacing;
+    if (ov.stackPrimarySizing != null)
+        updates.primaryAxisSizing = mapStackSizing(ov.stackPrimarySizing);
+    if (ov.stackCounterSizing != null)
+        updates.counterAxisSizing = mapStackSizing(ov.stackCounterSizing);
+    if (ov.stackPrimaryAlignItems != null)
+        updates.primaryAxisAlign = mapStackJustify(ov.stackPrimaryAlignItems);
+    if (ov.stackCounterAlignItems != null)
+        updates.counterAxisAlign = mapStackCounterAlign(ov.stackCounterAlignItems);
+    if (ov.stackChildPrimaryGrow != null)
+        updates.layoutGrow = ov.stackChildPrimaryGrow;
+    if (ov.stackChildAlignSelf != null)
+        updates.layoutAlignSelf = mapAlignSelf(ov.stackChildAlignSelf);
+    if (ov.stackPositioning != null)
+        updates.layoutPositioning =
+            ov.stackPositioning === 'ABSOLUTE' ? 'ABSOLUTE' : 'AUTO';
+    if (ov.stackVerticalPadding != null) {
+        updates.paddingTop = ov.stackVerticalPadding;
+        if (ov.stackPaddingBottom == null)
+            updates.paddingBottom = ov.stackVerticalPadding;
+    }
+    if (ov.stackHorizontalPadding != null) {
+        updates.paddingLeft = ov.stackHorizontalPadding;
+        if (ov.stackPaddingRight == null)
+            updates.paddingRight = ov.stackHorizontalPadding;
+    }
+    if (ov.stackPaddingBottom != null)
+        updates.paddingBottom = ov.stackPaddingBottom;
+    if (ov.stackPaddingRight != null)
+        updates.paddingRight = ov.stackPaddingRight;
+}
+function applyOverrideStrokes(ov, updates) {
+    if (ov.strokeWeight != null && !ov.strokePaints) {
+        updates.strokes = updates.strokes ?? [];
+    }
+    if (ov.strokeAlign != null && updates.strokes) {
+        const align = ov.strokeAlign === 'INSIDE' ? 'INSIDE' : (ov.strokeAlign === 'OUTSIDE' ? 'OUTSIDE' : 'CENTER');
+        for (const s of updates.strokes)
+            s.align = align;
+    }
+    if (ov.borderTopWeight != null)
+        updates.borderTopWeight = ov.borderTopWeight;
+    if (ov.borderRightWeight != null)
+        updates.borderRightWeight = ov.borderRightWeight;
+    if (ov.borderBottomWeight != null)
+        updates.borderBottomWeight = ov.borderBottomWeight;
+    if (ov.borderLeftWeight != null)
+        updates.borderLeftWeight = ov.borderLeftWeight;
+    if (ov.borderStrokeWeightsIndependent != null)
+        updates.independentStrokeWeights = ov.borderStrokeWeightsIndependent;
+}
+function applyOverrideText(ov, updates) {
+    if (ov.fontName != null) {
+        const fn = ov.fontName;
+        if (fn.family)
+            updates.fontFamily = fn.family;
+        if (fn.style) {
+            updates.fontWeight = styleToWeight(fn.style);
+            updates.italic = fn.style.toLowerCase().includes('italic');
+        }
+    }
+    if (ov.fontSize != null)
+        updates.fontSize = ov.fontSize;
+    if (ov.textAlignHorizontal != null)
+        updates.textAlignHorizontal = ov.textAlignHorizontal;
+    if (ov.textAutoResize != null)
+        updates.textAutoResize = ov.textAutoResize;
+    if (ov.lineHeight != null)
+        updates.lineHeight = convertLineHeight(ov.lineHeight, ov.fontSize);
+    if (ov.letterSpacing != null)
+        updates.letterSpacing = convertLetterSpacing(ov.letterSpacing, ov.fontSize);
+    if (ov.maxLines != null)
+        updates.maxLines = ov.maxLines;
+    if (ov.textTruncation != null)
+        updates.textTruncation =
+            ov.textTruncation === 'ENDING' ? 'ENDING' : 'DISABLED';
+    if (ov.textDecoration != null)
+        updates.textDecoration = mapTextDecoration(ov.textDecoration);
+}
+export function convertOverrideToProps(ov) {
+    const updates = {};
+    applyOverridePaints(ov, updates);
+    applyOverrideGeometry(ov, updates);
+    applyOverrideLayout(ov, updates);
+    applyOverrideStrokes(ov, updates);
+    applyOverrideText(ov, updates);
+    return updates;
+}
+//# sourceMappingURL=kiwi-convert.js.map