@doubao-apps/taro-runtime 0.0.18 → 0.0.19

package/dist/components/Input/index.d.ts

@@ -1,6 +1,4 @@
-type InputProps = {
-    value?: string;
-} & Record<string, unknown>;
-export declare function Input({ ...rest }: InputProps): any;
-export {};
+import type { InputRef as LynxInputRef } from '@byted-doubao-apps/components';
+import type { InputProps as TaroInputProps } from '@tarojs/components';
+export declare const Input: import("react").ForwardRefExoticComponent<Omit<TaroInputProps, "ref"> & import("react").RefAttributes<LynxInputRef>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/components/Input/index.jsx

@@ -1,5 +1,52 @@
-export function Input({ ...rest }) {
-    // @ts-expect-error
-    return <x-input-ng {...rest}/>;
+import { forwardRef, useCallback, useEffect, useRef } from '@byted-doubao-apps/framework';
+import { warnUnsupported } from '../base/warn-unsupported.js';
+import { mapInputProps, resolveFocusBehavior, toFocusEventDetail, toInputCommonEvent, toInputEventDetail, toSelectionChangeEventDetail, toValueEventDetail } from './map.js';
+export const Input = forwardRef(InputImpl);
+function InputImpl(props, ref) {
+    const { onInput, onFocus, onBlur, onConfirm, onSelectionChange, ...nonEventProps } = props;
+    const { mapped, unsupported, inputId, resolvedFocus, resolvedAutoFocus } = mapInputProps(nonEventProps);
+    const inputRef = useRef(null);
+    const hasAutoFocusedRef = useRef(false);
+    warnUnsupported('Input', unsupported);
+    const assignRef = useCallback((instance) => {
+        inputRef.current = instance;
+        assignForwardedRef(ref, instance);
+    }, [ref]);
+    useEffect(() => {
+        const { action, hasAutoFocused } = resolveFocusBehavior(resolvedFocus, resolvedAutoFocus, hasAutoFocusedRef.current);
+        hasAutoFocusedRef.current = hasAutoFocused;
+        if (action === 'focus') {
+            void inputRef.current?.focus();
+            return;
+        }
+        if (action === 'blur') {
+            void inputRef.current?.blur();
+        }
+    }, [resolvedAutoFocus, resolvedFocus]);
+    const handleInput = useCallback((event) => {
+        onInput?.(toInputCommonEvent(toInputEventDetail(event), 'input', inputId));
+    }, [inputId, onInput]);
+    const handleFocus = useCallback((event) => {
+        onFocus?.(toInputCommonEvent(toFocusEventDetail(event), 'focus', inputId));
+    }, [inputId, onFocus]);
+    const handleBlur = useCallback((event) => {
+        onBlur?.(toInputCommonEvent(toValueEventDetail(event), 'blur', inputId));
+    }, [inputId, onBlur]);
+    const handleConfirm = useCallback((event) => {
+        onConfirm?.(toInputCommonEvent(toValueEventDetail(event), 'confirm', inputId));
+    }, [inputId, onConfirm]);
+    const handleSelectionChange = useCallback((event) => {
+        onSelectionChange?.(toInputCommonEvent(toSelectionChangeEventDetail(event), 'selectionchange', inputId));
+    }, [inputId, onSelectionChange]);
+    return (<input {...mapped} ref={assignRef} {...(onInput ? { onInput: handleInput } : {})} {...(onFocus ? { onFocus: handleFocus } : {})} {...(onBlur ? { onBlur: handleBlur } : {})} {...(onConfirm ? { onConfirm: handleConfirm } : {})} {...(onSelectionChange ? { onSelectionChange: handleSelectionChange } : {})}/>);
+}
+function assignForwardedRef(ref, value) {
+    if (typeof ref === 'function') {
+        ref(value);
+        return;
+    }
+    if (ref) {
+        ref.current = value;
+    }
 }
 //# sourceMappingURL=index.jsx.map

package/dist/components/Input/map.d.ts

@@ -0,0 +1,50 @@
+import type { InputProps as LynxInputProps } from '@byted-doubao-apps/components';
+import type { InputProps as TaroInputProps } from '@tarojs/components';
+import type { PropMap } from '../types/prop-map.js';
+type LynxInputEvent = Parameters<NonNullable<LynxInputProps['onInput']>>[0];
+type LynxFocusEvent = Parameters<NonNullable<LynxInputProps['onFocus']>>[0];
+type LynxBlurEvent = Parameters<NonNullable<LynxInputProps['onBlur']>>[0];
+type LynxConfirmEvent = Parameters<NonNullable<LynxInputProps['onConfirm']>>[0];
+type LynxSelectionEvent = Parameters<NonNullable<LynxInputProps['onSelectionChange']>>[0];
+export type MappableTaroInputProps = Omit<TaroInputProps, 'onInput' | 'onFocus' | 'onBlur' | 'onConfirm' | 'onSelectionChange'>;
+export type InputCommonEvent<T = unknown> = {
+    type: string;
+    timeStamp: number;
+    target: {
+        id: string;
+        tagName: string;
+        dataset: Record<string, unknown>;
+    };
+    currentTarget: {
+        id: string;
+        tagName: string;
+        dataset: Record<string, unknown>;
+    };
+    detail: T;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+type FocusBehavior = {
+    action: 'focus' | 'blur' | null;
+    hasAutoFocused: boolean;
+};
+type MapInputPropsResult = {
+    mapped: Record<string, unknown>;
+    unsupported: string[];
+    inputId: string;
+    resolvedFocus: boolean | undefined;
+    resolvedAutoFocus: boolean | undefined;
+};
+export declare const INPUT_PROP_MAP: PropMap;
+export declare function mapInputProps(props: MappableTaroInputProps): MapInputPropsResult;
+export declare function resolveFocusBehavior(focus: boolean | undefined, autoFocus: boolean | undefined, hasAutoFocused: boolean): FocusBehavior;
+export declare function toInputCommonEvent<T>(detail: T, type: string, inputId: string): InputCommonEvent<T>;
+export declare function toInputEventDetail(event: LynxInputEvent): TaroInputProps.inputEventDetail;
+export declare function toFocusEventDetail(event: LynxFocusEvent): TaroInputProps.inputForceEventDetail;
+export declare function toValueEventDetail(event: LynxBlurEvent | LynxConfirmEvent): TaroInputProps.inputValueEventDetail;
+export declare function toSelectionChangeEventDetail(event: LynxSelectionEvent): {
+    selectionStart: number;
+    selectionEnd: number;
+};
+export {};
+//# sourceMappingURL=map.d.ts.map

package/dist/components/Input/map.js

@@ -0,0 +1,226 @@
+import { BASE_PROP_MAP } from '../base/prop-map.js';
+const SUPPORTED_INPUT_TYPES = new Set([
+    'text',
+    'number',
+    'digit',
+    'password',
+    'tel',
+    'email'
+]);
+export const INPUT_PROP_MAP = {
+    value: 'value',
+    defaultValue: 'defaultValue',
+    placeholder: 'placeholder',
+    disabled: 'disabled',
+    maxlength: 'maxlength',
+    confirmType: 'confirmType',
+    placeholderStyle: null,
+    placeholderClass: null,
+    placeholderTextColor: 'placeholderColor',
+    cursorSpacing: null,
+    confirmHold: null,
+    cursor: null,
+    cursorColor: null,
+    selectionStart: null,
+    selectionEnd: null,
+    adjustPosition: null,
+    holdKeyboard: null,
+    alwaysEmbed: null,
+    safePasswordCertPath: null,
+    safePasswordLength: null,
+    safePasswordTimeStamp: null,
+    safePasswordNonce: null,
+    safePasswordSalt: null,
+    safePasswordCustomHash: null,
+    randomNumber: null,
+    controlled: null,
+    nativeProps: null,
+    name: null,
+    alwaysSystem: null,
+    ariaLabel: null,
+    clueType: null,
+    onKeyboardHeightChange: null,
+    onNickNameReview: null,
+    onKeyboardCompositionStart: null,
+    onKeyboardCompositionUpdate: null,
+    onKeyboardCompositionEnd: null,
+    onKeyoardHeightChangeWorklet: null
+};
+export function mapInputProps(props) {
+    const { type, password, focus, autoFocus, ...rest } = props;
+    const mapped = {};
+    const unsupported = [];
+    Object.entries(rest).forEach(([key, value]) => {
+        if (key === 'placeholderStyle') {
+            mapPlaceholderStyle(value, mapped, unsupported);
+            return;
+        }
+        const target = INPUT_PROP_MAP[key] ?? BASE_PROP_MAP[key];
+        if (target) {
+            mapped[target] = value;
+            return;
+        }
+        unsupported.push(key);
+    });
+    const resolvedType = resolveInputType(type, password, unsupported);
+    if (resolvedType !== undefined) {
+        mapped.type = resolvedType;
+    }
+    const resolvedFocus = resolveBooleanProp(focus, 'focus', unsupported);
+    const resolvedAutoFocus = resolveBooleanProp(autoFocus, 'autoFocus', unsupported);
+    return {
+        mapped,
+        unsupported: dedupe(unsupported),
+        inputId: resolveInputId(mapped.id),
+        resolvedFocus,
+        resolvedAutoFocus
+    };
+}
+export function resolveFocusBehavior(focus, autoFocus, hasAutoFocused) {
+    if (typeof focus === 'boolean') {
+        return {
+            action: focus ? 'focus' : 'blur',
+            hasAutoFocused
+        };
+    }
+    if (!autoFocus || hasAutoFocused) {
+        return {
+            action: null,
+            hasAutoFocused
+        };
+    }
+    return {
+        action: 'focus',
+        hasAutoFocused: true
+    };
+}
+export function toInputCommonEvent(detail, type, inputId) {
+    return {
+        type,
+        timeStamp: Date.now(),
+        target: {
+            id: inputId,
+            tagName: 'input',
+            dataset: {}
+        },
+        currentTarget: {
+            id: inputId,
+            tagName: 'input',
+            dataset: {}
+        },
+        detail,
+        preventDefault: () => { },
+        stopPropagation: () => { }
+    };
+}
+export function toInputEventDetail(event) {
+    return {
+        value: event.detail.value,
+        cursor: event.detail.selectionEnd,
+        keyCode: 0
+    };
+}
+export function toFocusEventDetail(event) {
+    return {
+        value: event.detail.value,
+        height: 0
+    };
+}
+export function toValueEventDetail(event) {
+    return {
+        value: event.detail.value
+    };
+}
+export function toSelectionChangeEventDetail(event) {
+    return {
+        selectionStart: event.detail.selectionStart,
+        selectionEnd: event.detail.selectionEnd
+    };
+}
+function resolveInputType(type, password, unsupported) {
+    if (password !== undefined && typeof password !== 'boolean') {
+        unsupported.push('password');
+    }
+    if (password === true) {
+        return 'password';
+    }
+    if (type === undefined) {
+        return undefined;
+    }
+    if (typeof type === 'string' && SUPPORTED_INPUT_TYPES.has(type)) {
+        return type;
+    }
+    unsupported.push('type');
+    return 'text';
+}
+function resolveBooleanProp(value, key, unsupported) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    unsupported.push(key);
+    return undefined;
+}
+function resolveInputId(id) {
+    if (typeof id === 'string') {
+        return id;
+    }
+    if (typeof id === 'number') {
+        return String(id);
+    }
+    return '';
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+function mapPlaceholderStyle(placeholderStyle, mapped, unsupported) {
+    if (placeholderStyle === undefined) {
+        return;
+    }
+    if (typeof placeholderStyle !== 'string') {
+        unsupported.push('placeholderStyle');
+        return;
+    }
+    const declarationMap = parsePlaceholderStyle(placeholderStyle);
+    const placeholderFontSize = declarationMap['font-size'];
+    const placeholderFontWeight = declarationMap['font-weight'];
+    if (placeholderFontSize !== undefined) {
+        mapped.placeholderFontSize = placeholderFontSize;
+    }
+    if (placeholderFontWeight !== undefined) {
+        mapped.placeholderFontWeight = placeholderFontWeight;
+    }
+    if (placeholderFontSize === undefined && placeholderFontWeight === undefined) {
+        unsupported.push('placeholderStyle');
+    }
+}
+function parsePlaceholderStyle(style) {
+    const declarationMap = {};
+    style.split(';').forEach((declaration) => {
+        const declarationText = declaration.trim();
+        if (!declarationText) {
+            return;
+        }
+        const separatorIndex = declarationText.indexOf(':');
+        if (separatorIndex <= 0) {
+            return;
+        }
+        const property = normalizeStyleProperty(declarationText.slice(0, separatorIndex));
+        const value = declarationText.slice(separatorIndex + 1).trim();
+        if ((property === 'font-size' || property === 'font-weight') && value) {
+            declarationMap[property] = value;
+        }
+    });
+    return declarationMap;
+}
+function normalizeStyleProperty(property) {
+    return property
+        .trim()
+        .replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)
+        .replace(/\s+/g, '')
+        .replace(/^-/, '')
+        .toLowerCase();
+}
+//# sourceMappingURL=map.js.map

package/dist/components/Map/bridge.d.ts

@@ -1,3 +1,4 @@
+import type { MapMarkerProps } from '@byted-doubao-apps/components';
 import type { MapProps } from '@tarojs/components';
 export interface NativeRegionChangeDetail {
     type: 'begin' | 'end';
@@ -31,17 +32,34 @@ export interface NativeMarkerBridgeProps {
         zIndex: number;
     };
 }
+export interface MarkerElementPropsOptions {
+    nativeMarker: NativeMarkerBridgeProps;
+    onClick?: () => void;
+}
+export interface MarkerTextLayer {
+    key: 'callout' | 'label' | 'title';
+    content: string;
+    style: Record<string, unknown>;
+}
+export interface MarkerTextContent {
+    callout?: MarkerTextLayer;
+    label?: MarkerTextLayer;
+    title?: MarkerTextLayer;
+}
 export declare function normalizeSetting(setting: MapProps['setting']): Record<string, unknown>;
 export declare function getNumberSetting(setting: Record<string, unknown>, key: string): number | undefined;
 export declare function getBooleanSetting(setting: Record<string, unknown>, key: string): boolean | undefined;
 export declare function resolvePolylines(polylines: MapProps['polyline']): {
     id: string;
     points: MapProps.point[];
-    color: string | undefined;
+    edgeColor: string[] | undefined;
+    edgeTexture: string[] | undefined;
+    edgeTextureAssets: {
+        id: string;
+        url: string;
+    }[] | undefined;
     width: number | undefined;
     dottedLine: boolean | undefined;
-    arrowLine: boolean | undefined;
-    arrowLineIcon: string | undefined;
 }[];
 export declare function resolveCircles(circles: MapProps['circles']): {
     id: string;
@@ -63,12 +81,22 @@ export declare function resolveNativePolygons(polygons: MapProps.polygon[]): {
     fillColor: string | undefined;
     zIndex: number | undefined;
 }[];
-export declare function resolvePadding(padding: NonNullable<MapProps['includePadding']>): number | undefined;
+export declare function resolvePadding(padding: NonNullable<MapProps['includePadding']>): number[] | undefined;
 export declare function resolveCustomMapStyle(customMapStyle: MapProps['customMapStyle']): "normal-light" | "simple-light" | undefined;
 export declare function mapRegionChangeDetail(detail: NativeRegionChangeDetail): MapProps.onRegionEventDetail<'begin'> | MapProps.onRegionEventDetail<'end'>;
 export declare function mapPolylineTapDetail(id: string): MapProps.onPolylineTapEventDetail;
 export declare function mapMarkerToNativeProps(marker: MapProps.marker, index: number): NativeMarkerBridgeProps;
 export declare function getMarkerId(marker: MapProps.marker, index: number): number;
+export declare function createMarkerElementProps(options: MarkerElementPropsOptions): MapMarkerProps;
+export declare function hasByClickCallout(marker: MapProps.marker): boolean;
+export declare function hasTapTitle(marker: MapProps.marker): boolean;
+export declare function resolveMarkerIconStyle(marker: MapProps.marker): Record<string, unknown> | undefined;
+export declare function shouldAutoSizeMarkerIcon(marker: MapProps.marker): boolean;
+export declare function resolveMarkerTextContent(marker: MapProps.marker, markerId: string | number, activeCalloutMarkerId?: string | number): MarkerTextContent;
+export declare function composeMarkers(propMarkers: MapProps.marker[], addedMarkers: MapProps.marker[], removedMarkerIds: number[]): MapProps.marker[];
+export declare function mergeMarkersById(base: MapProps.marker[], incoming: MapProps.marker[]): MapProps.marker[];
+export declare function removeMarkersByIds(markers: MapProps.marker[], markerIds: number[]): MapProps.marker[];
+export declare function getNumericMarkerId(marker: MapProps.marker): number | undefined;
 export declare function mapRegionCausedByEnd(causedBy: 'drag' | 'scale' | 'rotate'): "scale" | "drag" | "update";
 export declare function toNativeRegionChangeDetail(detail: NativeRegionChangeLike): NativeRegionChangeDetail;
 export declare function dispatchMarkerTapEvent<T>(handlers: {

package/dist/components/Map/bridge.js

@@ -11,15 +11,46 @@ export function getBooleanSetting(setting, key) {
     return typeof setting[key] === 'boolean' ? setting[key] : undefined;
 }
 export function resolvePolylines(polylines) {
-    return (polylines ?? []).map((item, index) => ({
-        id: String(getOptionalId(item, index)),
-        points: item.points,
-        color: item.color,
-        width: item.width,
-        dottedLine: item.dottedLine,
-        arrowLine: item.arrowLine,
-        arrowLineIcon: item.arrowIconPath
-    }));
+    return (polylines ?? []).map((item, index) => {
+        // Map color list to Doubao edgeColor
+        const colorList = item.colorList ??
+            item.colors;
+        const edgeColor = Array.isArray(colorList)
+            ? colorList
+            : typeof item.color === 'string'
+                ? [item.color]
+                : undefined;
+        // Map arrow line/icon to Doubao edgeTexture + edgeTextureAssets
+        let edgeTexture;
+        let edgeTextureAssets;
+        const segmentCount = Array.isArray(item.points) ? Math.max(item.points.length - 1, 0) : 0;
+        const arrowIconPath = item.arrowIconPath;
+        const arrowLine = item.arrowLine;
+        if (arrowLine && typeof arrowIconPath === 'string' && segmentCount > 0) {
+            // Use a deterministic id per icon path
+            const textureId = `arrow_${hashString(arrowIconPath)}`;
+            edgeTextureAssets = [{ id: textureId, url: arrowIconPath }];
+            edgeTexture = new Array(segmentCount).fill(textureId);
+        }
+        return {
+            id: String(getOptionalId(item, index)),
+            points: item.points,
+            edgeColor,
+            edgeTexture,
+            edgeTextureAssets,
+            width: item.width,
+            dottedLine: item.dottedLine
+        };
+    });
+}
+function hashString(s) {
+    // Simple non-crypto hash for id stability
+    let h = 0;
+    for (let i = 0; i < s.length; i++) {
+        h = (h << 5) - h + s.charCodeAt(i);
+        h |= 0; // convert to 32-bit
+    }
+    return Math.abs(h).toString(36);
 }
 export function resolveCircles(circles) {
     return (circles ?? []).map((item, index) => ({
@@ -46,11 +77,11 @@ export function resolveNativePolygons(polygons) {
     }));
 }
 export function resolvePadding(padding) {
-    const values = [padding.left, padding.right, padding.top, padding.bottom];
+    const values = [padding.top, padding.left, padding.bottom, padding.right];
     if (values.some((value) => typeof value !== 'number')) {
         return undefined;
     }
-    return values.every((value) => value === values[0]) ? values[0] : undefined;
+    return values;
 }
 export function resolveCustomMapStyle(customMapStyle) {
     if (customMapStyle === 'default') {
@@ -111,14 +142,111 @@ export function mapMarkerToNativeProps(marker, index) {
             longitude: marker.longitude
         },
         anchor: marker.anchor ? [marker.anchor.x, marker.anchor.y] : [0.5, 1],
-        alpha: marker.alpha,
-        rotation: marker.rotate,
+        alpha: marker.alpha ?? 1,
+        rotation: marker.rotate ?? 0,
         zIndexStyle: marker.zIndex === undefined ? undefined : { zIndex: marker.zIndex }
     };
 }
 export function getMarkerId(marker, index) {
     return marker.id ?? index;
 }
+export function createMarkerElementProps(options) {
+    const props = {
+        position: options.nativeMarker.position,
+        anchor: options.nativeMarker.anchor,
+        alpha: options.nativeMarker.alpha,
+        rotation: options.nativeMarker.rotation,
+        clickable: true,
+        children: null,
+        draggable: false
+    };
+    if (options.nativeMarker.zIndexStyle !== undefined) {
+        props.style = options.nativeMarker.zIndexStyle;
+    }
+    if (options.onClick !== undefined) {
+        props.onClick = options.onClick;
+    }
+    return props;
+}
+export function hasByClickCallout(marker) {
+    return (Boolean(marker.callout?.content) &&
+        marker.customCallout === undefined &&
+        marker.callout?.display !== 'ALWAYS');
+}
+export function hasTapTitle(marker) {
+    return marker.customCallout === undefined && !hasText(marker.callout?.content) && hasText(marker.title);
+}
+export function resolveMarkerIconStyle(marker) {
+    const style = {};
+    if (marker.width !== undefined) {
+        style.width = normalizeStyleSize(marker.width);
+    }
+    if (marker.height !== undefined) {
+        style.height = normalizeStyleSize(marker.height);
+    }
+    return Object.keys(style).length > 0 ? style : undefined;
+}
+export function shouldAutoSizeMarkerIcon(marker) {
+    return marker.width === undefined || marker.height === undefined;
+}
+export function resolveMarkerTextContent(marker, markerId, activeCalloutMarkerId) {
+    const hasCustomCallout = marker.customCallout !== undefined;
+    const calloutLayer = resolveCalloutLayer(marker, markerId, activeCalloutMarkerId);
+    const labelLayer = resolveLabelLayer(marker);
+    const hasCalloutContent = hasText(marker.callout?.content) && !hasCustomCallout;
+    const textContent = {};
+    if (calloutLayer) {
+        textContent.callout = calloutLayer;
+    }
+    if (labelLayer) {
+        textContent.label = labelLayer;
+    }
+    if (!hasCalloutContent &&
+        !hasCustomCallout &&
+        hasText(marker.title) &&
+        activeCalloutMarkerId === markerId) {
+        textContent.title = {
+            key: 'title',
+            content: marker.title,
+            style: createTextStyle({ marginBottom: 4 })
+        };
+    }
+    return textContent;
+}
+export function composeMarkers(propMarkers, addedMarkers, removedMarkerIds) {
+    const visiblePropMarkers = removeMarkersByIds(propMarkers, removedMarkerIds);
+    return mergeMarkersById(visiblePropMarkers, addedMarkers);
+}
+export function mergeMarkersById(base, incoming) {
+    const next = [...base];
+    incoming.forEach((marker) => {
+        const markerId = getNumericMarkerId(marker);
+        if (markerId === undefined) {
+            next.push(marker);
+            return;
+        }
+        const existingIndex = next.findIndex((item) => getNumericMarkerId(item) === markerId);
+        if (existingIndex === -1) {
+            next.push(marker);
+            return;
+        }
+        next[existingIndex] = marker;
+    });
+    return next;
+}
+export function removeMarkersByIds(markers, markerIds) {
+    if (markerIds.length === 0) {
+        return markers;
+    }
+    const markerIdSet = new Set(markerIds);
+    return markers.filter((marker) => {
+        const markerId = getNumericMarkerId(marker);
+        return markerId === undefined || !markerIdSet.has(markerId);
+    });
+}
+export function getNumericMarkerId(marker) {
+    return typeof marker.id === 'number' ? marker.id : undefined;
+}
 export function mapRegionCausedByEnd(causedBy) {
     if (causedBy === 'drag' || causedBy === 'scale') {
         return causedBy;
@@ -154,4 +282,87 @@ export function getOptionalId(value, fallback) {
     const candidate = value.id;
     return candidate ?? fallback;
 }
+function resolveCalloutLayer(marker, markerId, activeCalloutMarkerId) {
+    if (marker.customCallout !== undefined) {
+        return undefined;
+    }
+    const callout = marker.callout;
+    if (!hasText(callout?.content)) {
+        return undefined;
+    }
+    const calloutDisplay = callout.display ?? 'BYCLICK';
+    if (calloutDisplay !== 'ALWAYS' && activeCalloutMarkerId !== markerId) {
+        return undefined;
+    }
+    return {
+        key: 'callout',
+        content: callout.content,
+        style: createTextStyle({
+            marginBottom: 4,
+            padding: callout.padding ?? 6,
+            color: callout.color ?? '#222222',
+            backgroundColor: callout.bgColor ?? '#ffffff',
+            borderRadius: callout.borderRadius ?? 8,
+            borderWidth: callout.borderWidth ?? 0,
+            borderColor: callout.borderColor ?? 'transparent',
+            fontSize: callout.fontSize ?? 12,
+            textAlign: callout.textAlign ?? 'center',
+            offsetX: callout.anchorX,
+            offsetY: callout.anchorY
+        })
+    };
+}
+function resolveLabelLayer(marker) {
+    const label = marker.label;
+    if (!hasText(label?.content)) {
+        return undefined;
+    }
+    return {
+        key: 'label',
+        content: label.content,
+        style: createTextStyle({
+            marginBottom: 4,
+            padding: label.padding ?? 6,
+            color: label.color ?? '#222222',
+            backgroundColor: label.bgColor ?? '#ffffff',
+            borderRadius: label.borderRadius ?? 8,
+            borderWidth: label.borderWidth ?? 0,
+            borderColor: label.borderColor ?? 'transparent',
+            fontSize: label.fontSize ?? 12,
+            textAlign: label.textAlign ?? 'center',
+            offsetX: label.anchorX,
+            offsetY: label.anchorY
+        })
+    };
+}
+function createTextStyle(options) {
+    const style = {
+        marginBottom: normalizeStyleSize(options.marginBottom ?? 0),
+        padding: normalizeStyleSize(options.padding ?? 0),
+        color: options.color ?? '#222222',
+        backgroundColor: options.backgroundColor ?? 'transparent',
+        borderRadius: normalizeStyleSize(options.borderRadius ?? 0),
+        borderWidth: normalizeStyleSize(options.borderWidth ?? 0),
+        borderColor: options.borderColor ?? 'transparent',
+        fontSize: normalizeStyleSize(options.fontSize ?? 12),
+        textAlign: options.textAlign ?? 'center',
+        maxWidth: normalizeStyleSize(240)
+    };
+    if (typeof options.offsetX === 'number' || typeof options.offsetY === 'number') {
+        style.position = 'relative';
+    }
+    if (typeof options.offsetX === 'number') {
+        style.left = normalizeStyleSize(options.offsetX);
+    }
+    if (typeof options.offsetY === 'number') {
+        style.top = normalizeStyleSize(options.offsetY);
+    }
+    return style;
+}
+function hasText(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function normalizeStyleSize(value) {
+    return typeof value === 'number' ? `${value}px` : value;
+}
 //# sourceMappingURL=bridge.js.map