@doubao-apps/taro-runtime 0.0.18 → 0.0.19

package/dist/components/Map/index.jsx

@@ -1,13 +1,16 @@
-import { useEffect, useRef } from '@byted-doubao-apps/framework';
+import { useEffect, useRef, useState } from '@byted-doubao-apps/framework';
 import { registerMapController, unregisterMapController } from '../../internal/map-context/index.js';
 import { Image } from '../Image/index.jsx';
 import { warnUnsupported } from '../base/warn-unsupported.js';
-import { dispatchMarkerTapEvent, mapMarkerToNativeProps, resolvePadding } from './bridge.js';
+import { composeMarkers, createMarkerElementProps, dispatchMarkerTapEvent, getNumericMarkerId, hasByClickCallout, hasTapTitle, mapMarkerToNativeProps, mergeMarkersById, removeMarkersByIds, resolveMarkerIconStyle, resolveMarkerTextContent, shouldAutoSizeMarkerIcon, resolvePadding } from './bridge.js';
 import { collectMapUnsupportedWarnings, createMapElementProps, resolveMapValues, toCommonEvent } from './mapping.js';
 export function Map(props) {
     const { id, className, style, hidden, animation, children, onTouchStart, onTouchMove, onTouchCancel, onTouchEnd, onClick: onBaseClick, onLongPress, onLongClick, onTransitionEnd, onAnimationStart, onAnimationIteration, onAnimationEnd, longitude, latitude, scale, minScale, maxScale, markers, covers, polyline, circles, controls, includePoints, showLocation, polygons, subkey, layerStyle, rotate, skew, showCompass, showScale, enableOverlooking, enableZoom, enableScroll, enableRotate, enableSatellite, enableTraffic, setting, includePadding, groundOverlays, tileOverlay, enablePoi, enableBuilding, polygon, customMapStyle, panels, theme, optimize, enableAutoMaxOverlooking, enable3D, onTap, onMarkerTap, onLabelTap, onControlTap, onCalloutTap, onUpdated, onRegionChange, onPoiTap, onPolylineTap, onAbilitySuccess, onAbilityFailed, onAuthSuccess, onInterpolatePoint, onError, onCallOutTap, onAnchorPointTap, onPanelTap, onInitComplete, ...rest } = props;
     const mapRef = useRef(null);
     const mapControllerRef = useRef(null);
+    const [activeCalloutMarkerId, setActiveCalloutMarkerId] = useState(undefined);
+    const [imperativeAddedMarkers, setImperativeAddedMarkers] = useState([]);
+    const [imperativeRemovedMarkerIds, setImperativeRemovedMarkerIds] = useState([]);
     const { resolvedSetting, resolvedScale, resolvedMinScale, resolvedMaxScale, resolvedRotate, resolvedShowScale, resolvedEnableTilt, resolvedEnableScale, resolvedEnableDrag, resolvedEnableRotate, resolvedMarkers, resolvedPolygons, resolvedMapStyle } = resolveMapValues({
         setting,
         scale,
@@ -27,7 +30,11 @@ export function Map(props) {
     });
     const mapId = id ? String(id) : '';
     if (!mapControllerRef.current) {
-        mapControllerRef.current = createMapController(mapRef);
+        mapControllerRef.current = createMapController({
+            mapRef,
+            setImperativeAddedMarkers,
+            setImperativeRemovedMarkerIds
+        });
     }
     const unsupported = collectMapUnsupportedWarnings({
         unsupportedValues: {
@@ -136,79 +143,92 @@ export function Map(props) {
         onLabelTap !== undefined ||
         onCalloutTap !== undefined ||
         onCallOutTap !== undefined;
+    const renderMarkers = composeMarkers(resolvedMarkers, imperativeAddedMarkers, imperativeRemovedMarkerIds);
     return (<map {...mapElementProps}>
-      {resolvedMarkers.map((marker, index) => {
+      {renderMarkers.map((marker, index) => {
             const nativeMarker = mapMarkerToNativeProps(marker, index);
+            const markerId = nativeMarker.markerId;
             const markerTapEvent = toCommonEvent({
-                markerId: nativeMarker.markerId
+                markerId
             }, 'markertap', mapId);
-            const markerElementProps = {
-                children: marker.children,
-                key: String(nativeMarker.markerId),
-                position: nativeMarker.position,
-                anchor: nativeMarker.anchor,
-                alpha: nativeMarker.alpha,
-                rotation: nativeMarker.rotation,
-                zIndex: nativeMarker.zIndexStyle?.zIndex,
-                clickable: true,
-                draggable: marker.draggable,
-                onClick: shouldDispatchMarkerTap
-                    ? () => {
+            const shouldActivateByClickCallout = hasByClickCallout(marker);
+            const shouldActivateTitle = hasTapTitle(marker);
+            const shouldActivateMarkerText = shouldActivateByClickCallout || shouldActivateTitle;
+            const handleMarkerClick = shouldDispatchMarkerTap || shouldActivateMarkerText
+                ? () => {
+                    if (shouldActivateMarkerText) {
+                        setActiveCalloutMarkerId(markerId);
+                    }
+                    if (shouldDispatchMarkerTap) {
                         dispatchMarkerTapEvent(markerTapHandlers, markerTapEvent);
                     }
-                    : undefined
-            };
-            return (<map-marker key={nativeMarker.markerId} {...markerElementProps}>
-            <view style={{
-                    display: 'flex',
-                    flexDirection: 'column',
-                    alignItems: 'center'
-                }}>
-              {renderMarkerBubble(marker)}
-              <Image src={marker.iconPath} style={{
-                    width: marker.width,
-                    height: marker.height
-                }}/>
-            </view>
-          </map-marker>);
+                }
+                : undefined;
+            const markerElementProps = createMarkerElementProps({
+                nativeMarker,
+                onClick: handleMarkerClick
+            });
+            const markerContent = marker.children !== undefined
+                ? marker.children
+                : renderDefaultMarkerContent(marker, markerId, activeCalloutMarkerId);
+            return (
+            // biome-ignore lint: key is not sure
+            <map-marker {...markerElementProps}>{markerContent}</map-marker>);
         })}
       {children}
     </map>);
 }
-function renderMarkerBubble(marker) {
-    const content = marker.callout?.content ?? marker.label?.content ?? marker.title;
-    if (!content) {
-        return null;
-    }
-    const bubble = marker.callout ?? marker.label;
-    return (<text style={{
-            marginBottom: 4,
-            padding: bubble?.padding ?? 6,
-            color: bubble?.color ?? '#222222',
-            backgroundColor: bubble?.bgColor ?? '#ffffff',
-            borderRadius: bubble?.borderRadius ?? 8,
-            borderWidth: bubble?.borderWidth ?? 0,
-            borderColor: bubble?.borderColor ?? 'transparent',
-            fontSize: bubble?.fontSize ?? 12,
-            textAlign: bubble?.textAlign ?? 'center',
-            maxWidth: 240
+function renderDefaultMarkerContent(marker, markerId, activeCalloutMarkerId) {
+    const textContent = resolveMarkerTextContent(marker, markerId, activeCalloutMarkerId);
+    const iconStyle = resolveMarkerIconStyle(marker);
+    const shouldAutoSizeIcon = shouldAutoSizeMarkerIcon(marker);
+    return (<view style={{
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center'
         }}>
-      {content}
-    </text>);
+      {textContent.callout ? (<text style={textContent.callout.style}>{textContent.callout.content}</text>) : null}
+      {textContent.label ? <text style={textContent.label.style}>{textContent.label.content}</text> : null}
+      {textContent.title ? <text style={textContent.title.style}>{textContent.title.content}</text> : null}
+      <Image src={marker.iconPath} style={iconStyle} autoSize={shouldAutoSizeIcon}/>
+    </view>);
 }
-function createMapController(mapRef) {
+function createMapController(options) {
     return {
-        getCenter: () => getMapInstance(mapRef).getCenter(),
+        getCenter: () => getMapInstance(options.mapRef).getCenter(),
         setCenter: (center, scaleValue) => {
-            getMapInstance(mapRef).setCenter(center, scaleValue);
+            getMapInstance(options.mapRef).setCenter(center, scaleValue);
         },
-        getScale: () => getMapInstance(mapRef).getScale(),
-        getBound: () => getMapInstance(mapRef).getBound(),
+        getScale: () => getMapInstance(options.mapRef).getScale(),
+        getBound: () => getMapInstance(options.mapRef).getBound(),
         fitPoints: (points, padding) => {
-            getMapInstance(mapRef).fitPoints(points, padding);
+            getMapInstance(options.mapRef).fitPoints(points, padding);
         },
         setAnchor: (position) => {
-            getMapInstance(mapRef).setAnchor(position);
+            getMapInstance(options.mapRef).setAnchor(position);
+        },
+        addMarkers: (markers, clear) => {
+            const runtimeMarkers = markers;
+            const shouldClear = clear === true;
+            options.setImperativeAddedMarkers((previousAddedMarkers) => mergeMarkersById(shouldClear ? [] : previousAddedMarkers, runtimeMarkers));
+            options.setImperativeRemovedMarkerIds((previousRemovedMarkerIds) => {
+                const baseRemovedMarkerIds = shouldClear ? [] : previousRemovedMarkerIds;
+                const restoredMarkerIds = runtimeMarkers
+                    .map((marker) => getNumericMarkerId(marker))
+                    .filter((markerId) => markerId !== undefined);
+                if (restoredMarkerIds.length === 0) {
+                    return baseRemovedMarkerIds;
+                }
+                const restoredIdSet = new Set(restoredMarkerIds);
+                return baseRemovedMarkerIds.filter((markerId) => !restoredIdSet.has(markerId));
+            });
+        },
+        removeMarkers: (markerIds) => {
+            options.setImperativeAddedMarkers((previousAddedMarkers) => removeMarkersByIds(previousAddedMarkers, markerIds));
+            options.setImperativeRemovedMarkerIds((previousRemovedMarkerIds) => {
+                const markerIdSet = new Set([...previousRemovedMarkerIds, ...markerIds]);
+                return Array.from(markerIdSet);
+            });
         }
     };
 }

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

@@ -1,6 +1,7 @@
 import type { MapRef } from '@byted-doubao-apps/framework/components';
+import type { CSSProperties } from '@lynx-js/types';
 import type { MapProps } from '@tarojs/components';
-import { resolveCustomMapStyle } from './bridge.js';
+import { resolveCustomMapStyle, type NativeRegionChangeLike } from './bridge.js';
 type CommonEvent<T = unknown> = {
     type: string;
     timeStamp: number;
@@ -18,6 +19,12 @@ type CommonEvent<T = unknown> = {
     preventDefault: () => void;
     stopPropagation: () => void;
 };
+type NativeMapClickDetail = {
+    point: MapProps.point;
+};
+type NativeMapPolylineClickDetail = {
+    id: string;
+};
 type ResolvedMapValues = {
     resolvedSetting: Record<string, unknown>;
     resolvedScale: number;
@@ -80,7 +87,6 @@ type CreateMapElementPropsOptions = {
 declare const MAP_UNSUPPORTED_PROPS: readonly ["animation", "controls", "showLocation", "subkey", "layerStyle", "skew", "showCompass", "enableSatellite", "enableTraffic", "groundOverlays", "tileOverlay", "enablePoi", "enableBuilding", "panels", "theme", "optimize", "enableAutoMaxOverlooking", "enable3D", "onTouchStart", "onTouchMove", "onTouchCancel", "onTouchEnd", "onLongPress", "onLongClick", "onTransitionEnd", "onAnimationStart", "onAnimationIteration", "onAnimationEnd", "onControlTap", "onPoiTap", "onAbilitySuccess", "onAbilityFailed", "onAuthSuccess", "onInterpolatePoint", "onError", "onAnchorPointTap", "onPanelTap"];
 export type RuntimeMarker = MapProps.marker & {
     children?: unknown;
-    draggable?: boolean;
 };
 export declare function resolveMapValues(values: {
     setting: MapProps['setting'];
@@ -100,7 +106,69 @@ export declare function resolveMapValues(values: {
     customMapStyle: MapProps['customMapStyle'];
 }): ResolvedMapValues;
 export declare function collectMapUnsupportedWarnings(options: CollectUnsupportedOptions): string[];
-export declare function createMapElementProps(options: CreateMapElementPropsOptions): Record<string, unknown>;
+export declare function createMapElementProps(options: CreateMapElementPropsOptions): {
+    id: string;
+    className: string;
+    ref: {
+        current: MapRef | null;
+    };
+    style: CSSProperties;
+    mapStyle: "normal-light" | "simple-light" | undefined;
+    center: {
+        latitude: number;
+        longitude: number;
+    };
+    scale: number;
+    minScale: number;
+    maxScale: number;
+    rotate: number;
+    showScale: boolean;
+    enableTilt: boolean;
+    enableScale: boolean;
+    enableDrag: boolean;
+    enableRotate: boolean;
+    polyline: {
+        id: string;
+        points: MapProps.point[];
+        edgeColor: string[] | undefined;
+        edgeTexture: string[] | undefined;
+        edgeTextureAssets: {
+            id: string;
+            url: string;
+        }[] | undefined;
+        width: number | undefined;
+        dottedLine: boolean | undefined;
+    }[];
+    circles: (Omit<{
+        id: string;
+        center: {
+            latitude: number;
+            longitude: number | undefined;
+        };
+        radius: number;
+        strokeWidth: number | undefined;
+        strokeColor: string | undefined;
+        fillColor: string | undefined;
+    }, "center"> & {
+        center: {
+            latitude: number;
+            longitude: number;
+        };
+    })[];
+    polygons: {
+        id: string;
+        points: MapProps.point[];
+        dottedLine: boolean | undefined;
+        strokeWidth: number | undefined;
+        strokeColor: string | undefined;
+        fillColor: string | undefined;
+        zIndex: number | undefined;
+    }[];
+    onClick: (detail: NativeMapClickDetail) => void;
+    onMapLoaded: () => void;
+    onRegionChange: (detail: NativeRegionChangeLike) => void;
+    onPolylineClick: (detail: NativeMapPolylineClickDetail) => void;
+};
 export declare function toCommonEvent<T>(detail: T, type: string, mapId: string): CommonEvent<T>;
 export {};
 //# sourceMappingURL=mapping.d.ts.map

package/dist/components/Map/mapping.js

@@ -140,21 +140,6 @@ function collectShapeWarnings(markers, polylines, circles, polygons) {
     if (markers.some((marker) => marker.ariaLabel !== undefined)) {
         unsupported.push('markers[].ariaLabel');
     }
-    if (markers.some((marker) => marker.callout?.anchorX !== undefined)) {
-        unsupported.push('markers[].callout.anchorX');
-    }
-    if (markers.some((marker) => marker.callout?.anchorY !== undefined)) {
-        unsupported.push('markers[].callout.anchorY');
-    }
-    if (markers.some((marker) => marker.callout?.display !== undefined)) {
-        unsupported.push('markers[].callout.display');
-    }
-    if (markers.some((marker) => marker.label?.anchorX !== undefined)) {
-        unsupported.push('markers[].label.anchorX');
-    }
-    if (markers.some((marker) => marker.label?.anchorY !== undefined)) {
-        unsupported.push('markers[].label.anchorY');
-    }
     if ((polylines ?? []).some((item) => item.borderColor !== undefined)) {
         unsupported.push('polyline[].borderColor');
     }

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

@@ -0,0 +1,8 @@
+import type { PickerColumnOption } from '@byted-doubao-apps/framework/components';
+import { type TaroPickerViewProps, type TaroPickerViewColumnProps } from './map.js';
+export declare function PickerView(props: TaroPickerViewProps): any;
+export declare function PickerViewColumn(_props: TaroPickerViewColumnProps & {
+    __mappedOptions?: PickerColumnOption[];
+    __mappedValue?: string | number;
+}): any;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/PickerView/index.jsx

@@ -0,0 +1,47 @@
+import { Children, cloneElement } from 'react';
+import { PickerView as DoubaoPickerView, PickerColumn as DoubaoPickerColumn } from '@byted-doubao-apps/components';
+import { buildOptionsFromRange, mapPickerViewProps, toPickerViewChangeEvent, warnUnsupportedPickerView } from './map.js';
+export function PickerView(props) {
+    const { value, onChange, children, ...rest } = props;
+    const { mapped, unsupported } = mapPickerViewProps(rest);
+    warnUnsupportedPickerView(unsupported);
+    // Collect ranges from child columns to compute indices on change
+    const ranges = [];
+    const childrenWithProps = Children.map(children, (child, index) => {
+        if (!child)
+            return child;
+        // We expect child to be <PickerViewColumn range={...} />
+        const range = child?.props?.range;
+        const options = buildOptionsFromRange(range);
+        ranges[index] = options;
+        const selectedIndex = Array.isArray(value) ? value[index] : undefined;
+        const selectedValue = selectedIndex != null && options[selectedIndex] ? options[selectedIndex].value : undefined;
+        return cloneElement(child, {
+            __mappedOptions: options,
+            __mappedValue: selectedValue
+        });
+    });
+    const handleChange = (values, selectedOptions) => {
+        // Map selected values back to indices per column
+        const indices = values.map((val, idx) => {
+            const opts = ranges[idx] ?? [];
+            const found = opts.findIndex((opt) => opt.value === val);
+            return found >= 0 ? found : 0;
+        });
+        onChange?.(toPickerViewChangeEvent(indices));
+    };
+    return (<DoubaoPickerView {...mapped} onChange={onChange ? handleChange : undefined}>
+      {Children.map(childrenWithProps, (child) => {
+            const options = child?.props?.__mappedOptions;
+            const valueForColumn = child?.props?.__mappedValue;
+            const columnClassName = child?.props?.className;
+            const columnStyle = child?.props?.style;
+            return (<DoubaoPickerColumn options={options ?? []} value={valueForColumn} className={columnClassName} style={columnStyle}/>);
+        })}
+    </DoubaoPickerView>);
+}
+export function PickerViewColumn(_props) {
+    // This is a placeholder wrapper. Real rendering is performed by PickerView above after mapping.
+    return null;
+}
+//# sourceMappingURL=index.jsx.map

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

@@ -0,0 +1,36 @@
+import type { CSSProperties } from '@lynx-js/types';
+import type { PickerViewProps as LynxPickerViewProps, PickerColumnOption } from '@byted-doubao-apps/framework/components';
+export type TaroPickerViewProps = {
+    className?: string;
+    style?: CSSProperties;
+    value?: number[];
+    indicatorStyle?: CSSProperties;
+    maskStyle?: CSSProperties;
+    onChange?: (event: {
+        type: string;
+        timeStamp: number;
+        detail: {
+            value: number[];
+        };
+    }) => void;
+    children?: any;
+};
+export type TaroPickerViewColumnProps = {
+    range?: Array<string | number>;
+    className?: string;
+    style?: CSSProperties;
+};
+export declare function toPickerViewChangeEvent(indices: number[]): {
+    type: string;
+    timeStamp: number;
+    detail: {
+        value: number[];
+    };
+};
+export declare function buildOptionsFromRange(range?: Array<string | number>): PickerColumnOption[];
+export declare function warnUnsupportedPickerView(unsupported: string[]): void;
+export declare function mapPickerViewProps(props: TaroPickerViewProps): {
+    mapped: Pick<LynxPickerViewProps, 'className' | 'style'>;
+    unsupported: string[];
+};
+//# sourceMappingURL=map.d.ts.map

package/dist/components/PickerView/map.js

@@ -0,0 +1,29 @@
+export function toPickerViewChangeEvent(indices) {
+    return {
+        type: 'change',
+        timeStamp: Date.now(),
+        detail: { value: indices }
+    };
+}
+export function buildOptionsFromRange(range) {
+    return (range ?? []).map((item) => ({ label: String(item), value: item }));
+}
+export function warnUnsupportedPickerView(unsupported) {
+    if (unsupported.length > 0) {
+        // Centralized warn helper exists for other components; keep inline minimal here
+        console.warn(`[PickerView] Unsupported props: ${unsupported.join(', ')}`);
+    }
+}
+export function mapPickerViewProps(props) {
+    const unsupported = [];
+    if (props.maskStyle)
+        unsupported.push('maskStyle');
+    if (props.indicatorStyle)
+        unsupported.push('indicatorStyle');
+    const mapped = {
+        className: props.className,
+        style: props.style
+    };
+    return { mapped, unsupported };
+}
+//# sourceMappingURL=map.js.map

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

@@ -0,0 +1,5 @@
+import type { RadioProps as TaroRadioProps } from '@tarojs/components';
+declare function RadioImpl(props: TaroRadioProps): any;
+export declare const Radio: typeof RadioImpl;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Radio/index.jsx

@@ -0,0 +1,82 @@
+import { useCallback, useContext, useEffect, useRef, useState } from '@byted-doubao-apps/framework';
+import { warnUnsupported } from '../base/warn-unsupported.js';
+import { RadioGroupRuntimeContext } from '../RadioGroup/context.js';
+import { mapRadioProps, resolveLynxRadioValue, resolveStandaloneSelectedValue, shouldDispatchStandaloneRadioChange, toRadioChangeEvent } from './map.js';
+import { markRuntimeRadio } from './shared.js';
+function RadioImpl(props) {
+    const { children, onChange, ...nonEventProps } = props;
+    const { mapped, unsupported, radioId, resolvedValue, resolvedDisabled, resolvedChecked } = mapRadioProps(nonEventProps);
+    const groupContext = useContext(RadioGroupRuntimeContext);
+    const warnedMissingGroupValueRef = useRef(false);
+    const fallbackValueRef = useRef(`__taro_runtime_radio_missing_${nextMissingValueId()}`);
+    const [uncontrolledChecked, setUncontrolledChecked] = useState(resolvedChecked ?? false);
+    warnUnsupported('Radio', unsupported);
+    useEffect(() => {
+        if (!groupContext ||
+            resolvedValue !== undefined ||
+            warnedMissingGroupValueRef.current ||
+            isProduction()) {
+            return;
+        }
+        warnedMissingGroupValueRef.current = true;
+        // eslint-disable-next-line no-console
+        console.warn('[components-taro] Radio inside RadioGroup requires a string value.');
+    }, [groupContext, resolvedValue]);
+    useEffect(() => {
+        if (!groupContext || resolvedValue === undefined) {
+            return;
+        }
+        return groupContext.registerRadioOnChange(resolvedValue, () => {
+            onChange?.(toRadioChangeEvent({ value: resolvedValue }, 'change', radioId));
+        });
+    }, [groupContext, onChange, radioId, resolvedValue]);
+    const valueForLynx = resolveLynxRadioValue(resolvedValue, fallbackValueRef.current);
+    const handleGroupLabelTap = useCallback(() => {
+        if (!groupContext || groupContext.disabled || resolvedDisabled || resolvedValue === undefined) {
+            return;
+        }
+        groupContext.selectValue(resolvedValue);
+    }, [groupContext, resolvedDisabled, resolvedValue]);
+    const isStandaloneControlled = resolvedChecked !== undefined;
+    const isStandaloneChecked = isStandaloneControlled ? resolvedChecked : uncontrolledChecked;
+    const handleStandaloneSelect = useCallback(() => {
+        if (resolvedDisabled) {
+            return;
+        }
+        if (shouldDispatchStandaloneRadioChange(isStandaloneChecked)) {
+            onChange?.(toRadioChangeEvent({ value: resolvedValue }, 'change', radioId));
+        }
+        if (!isStandaloneControlled && !isStandaloneChecked) {
+            setUncontrolledChecked(true);
+        }
+    }, [isStandaloneChecked, isStandaloneControlled, onChange, radioId, resolvedDisabled, resolvedValue]);
+    if (groupContext) {
+        return (<view {...mapped}>
+        <radio value={valueForLynx} disabled={resolvedDisabled || groupContext.disabled}/>
+        {children !== undefined ? <view bindtap={handleGroupLabelTap}>{children}</view> : null}
+      </view>);
+    }
+    const standaloneSelectedValue = resolveStandaloneSelectedValue(isStandaloneChecked ?? false, valueForLynx);
+    const lynxStandaloneGroupProps = {
+        disabled: resolvedDisabled,
+        onValueChange: handleStandaloneSelect,
+        ...(standaloneSelectedValue !== null ? { value: standaloneSelectedValue } : {})
+    };
+    return (<view {...mapped}>
+      <radio-group {...lynxStandaloneGroupProps}>
+        <radio value={valueForLynx} disabled={resolvedDisabled}/>
+      </radio-group>
+      {children !== undefined ? <view bindtap={handleStandaloneSelect}>{children}</view> : null}
+    </view>);
+}
+export const Radio = markRuntimeRadio(RadioImpl);
+let missingValueId = 0;
+function nextMissingValueId() {
+    const current = missingValueId;
+    missingValueId += 1;
+    return current;
+}
+function isProduction() {
+    return (globalThis.process?.env?.NODE_ENV === 'production');
+}
+//# sourceMappingURL=index.jsx.map

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

@@ -0,0 +1,38 @@
+import type { RadioProps as TaroRadioProps } from '@tarojs/components';
+export type MappableTaroRadioProps = Omit<TaroRadioProps, 'children' | 'onChange'>;
+type CommonEvent<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 MapRadioPropsResult = {
+    mapped: Record<string, unknown>;
+    unsupported: string[];
+    radioId: string;
+    resolvedValue: string | undefined;
+    resolvedDisabled: boolean;
+    resolvedChecked: boolean | undefined;
+};
+export declare function mapRadioProps(props: MappableTaroRadioProps): MapRadioPropsResult;
+export declare function resolveLynxRadioValue(value: string | undefined, fallback: string): string;
+export declare function resolveStandaloneSelectedValue(isChecked: boolean, value: string): string | null;
+export declare function shouldDispatchStandaloneRadioChange(isChecked: boolean): boolean;
+export declare function toRadioChangeEvent(detail: {
+    value?: string;
+}, type: string, radioId: string): CommonEvent<{
+    value?: string;
+}>;
+export {};
+//# sourceMappingURL=map.d.ts.map

package/dist/components/Radio/map.js

@@ -0,0 +1,109 @@
+import { BASE_PROP_MAP } from '../base/prop-map.js';
+const RADIO_PROP_MAP = {
+    name: null,
+    nativeProps: null,
+    ariaLabel: null
+};
+const RADIO_LAYOUT_STYLE = {
+    display: 'flex',
+    alignItems: 'center',
+    columnGap: '8px'
+};
+export function mapRadioProps(props) {
+    const { value, checked, disabled, color, ...rest } = props;
+    const mapped = {};
+    const unsupported = [];
+    Object.entries(rest).forEach(([key, rawValue]) => {
+        const target = RADIO_PROP_MAP[key] ?? BASE_PROP_MAP[key];
+        if (target) {
+            mapped[target] = rawValue;
+            return;
+        }
+        unsupported.push(key);
+    });
+    const resolvedValue = resolveStringProp(value, 'value', unsupported);
+    const resolvedColor = resolveStringProp(color, 'color', unsupported);
+    const resolvedChecked = resolveBooleanProp(checked, 'checked', unsupported);
+    const resolvedDisabled = resolveBooleanProp(disabled, 'disabled', unsupported) ?? false;
+    mapped.style = mergeRadioWrapperStyle(mapped.style, resolvedColor);
+    return {
+        mapped,
+        unsupported: dedupe(unsupported),
+        radioId: resolveRadioId(mapped.id),
+        resolvedValue,
+        resolvedDisabled,
+        resolvedChecked
+    };
+}
+export function resolveLynxRadioValue(value, fallback) {
+    return value ?? fallback;
+}
+export function resolveStandaloneSelectedValue(isChecked, value) {
+    return isChecked ? value : null;
+}
+export function shouldDispatchStandaloneRadioChange(isChecked) {
+    return !isChecked;
+}
+export function toRadioChangeEvent(detail, type, radioId) {
+    return {
+        type,
+        timeStamp: Date.now(),
+        target: {
+            id: radioId,
+            tagName: 'radio',
+            dataset: {}
+        },
+        currentTarget: {
+            id: radioId,
+            tagName: 'radio',
+            dataset: {}
+        },
+        detail,
+        preventDefault: () => { },
+        stopPropagation: () => { }
+    };
+}
+function mergeRadioWrapperStyle(style, color) {
+    const colorStyle = color ? `--doubao-radio-primary-color:${color};` : '';
+    const layoutStyle = 'display:flex;align-items:center;column-gap:8px;';
+    if (typeof style === 'string') {
+        const normalized = style.endsWith(';') ? style : `${style};`;
+        return `${normalized}${layoutStyle}${colorStyle}`;
+    }
+    const styleObject = isObject(style) ? style : {};
+    return {
+        ...RADIO_LAYOUT_STYLE,
+        ...styleObject,
+        ...(color ? { '--doubao-radio-primary-color': color } : {})
+    };
+}
+function resolveStringProp(value, propName, unsupported) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    unsupported.push(propName);
+    return undefined;
+}
+function resolveBooleanProp(value, propName, unsupported) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    unsupported.push(propName);
+    return undefined;
+}
+function resolveRadioId(id) {
+    return typeof id === 'string' && id.length > 0 ? id : 'radio';
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function dedupe(values) {
+    return Array.from(new Set(values));
+}
+//# sourceMappingURL=map.js.map