@doubao-apps/taro-runtime 0.0.18 → 0.0.19

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

@@ -0,0 +1,7 @@
+import type { ReactElement } from '@byted-doubao-apps/framework';
+export declare const RUNTIME_RADIO_MARK: unique symbol;
+export declare function markRuntimeRadio<T extends object>(component: T): T;
+export declare function isRuntimeRadioElement(element: ReactElement | {
+    type?: unknown;
+}): boolean;
+//# sourceMappingURL=shared.d.ts.map

package/dist/components/Radio/shared.js

@@ -0,0 +1,9 @@
+export const RUNTIME_RADIO_MARK = Symbol.for('doubao.taro.runtime.radio');
+export function markRuntimeRadio(component) {
+    component[RUNTIME_RADIO_MARK] = true;
+    return component;
+}
+export function isRuntimeRadioElement(element) {
+    return Boolean(element.type?.[RUNTIME_RADIO_MARK]);
+}
+//# sourceMappingURL=shared.js.map

package/dist/components/RadioGroup/context.d.ts

@@ -0,0 +1,11 @@
+export type RadioGroupOnChangeHandler = () => void;
+export type RegisterRadioOnChange = (value: string, handler: RadioGroupOnChangeHandler) => () => void;
+export type RadioGroupRuntimeContextValue = {
+    groupId: string;
+    selectedValue: string | null;
+    disabled: boolean;
+    selectValue: (value: string) => void;
+    registerRadioOnChange: RegisterRadioOnChange;
+};
+export declare const RadioGroupRuntimeContext: import("react").Context<RadioGroupRuntimeContextValue | null>;
+//# sourceMappingURL=context.d.ts.map

package/dist/components/RadioGroup/context.js

@@ -0,0 +1,3 @@
+import { createContext } from '@byted-doubao-apps/framework';
+export const RadioGroupRuntimeContext = createContext(null);
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1,3 @@
+import type { RadioGroupProps as TaroRadioGroupProps } from '@tarojs/components';
+export declare function RadioGroup(props: TaroRadioGroupProps): any;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/RadioGroup/index.jsx

@@ -0,0 +1,80 @@
+import { useCallback, useMemo, useRef, useState } from '@byted-doubao-apps/framework';
+import { warnUnsupported } from '../base/warn-unsupported.js';
+import { RadioGroupRuntimeContext } from './context.js';
+import { mapRadioGroupProps, resolveCheckedRadioSelection, resolveGroupSelectedValue, shouldDispatchGroupChange, toRadioGroupChangeEvent } from './map.js';
+export function RadioGroup(props) {
+    const { children, onChange, ...nonEventProps } = props;
+    const { mapped, unsupported, groupId, resolvedDisabled } = mapRadioGroupProps(nonEventProps);
+    const checkedSelection = resolveCheckedRadioSelection(children);
+    const { hasCheckedRadio, selectedValue: checkedValue, missingValueCount } = checkedSelection;
+    warnUnsupported('RadioGroup', unsupported);
+    warnCheckedRadioValueMissing(missingValueCount);
+    const [uncontrolledValue, setUncontrolledValue] = useState(checkedValue);
+    const radioChangeHandlersRef = useRef(new Map());
+    const selectedValue = resolveGroupSelectedValue(hasCheckedRadio, checkedValue, uncontrolledValue);
+    const registerRadioOnChange = useCallback((value, handler) => {
+        const handlerMap = radioChangeHandlersRef.current;
+        const bucket = handlerMap.get(value) ?? new Set();
+        bucket.add(handler);
+        handlerMap.set(value, bucket);
+        return () => {
+            const current = handlerMap.get(value);
+            if (!current) {
+                return;
+            }
+            current.delete(handler);
+            if (current.size === 0) {
+                handlerMap.delete(value);
+            }
+        };
+    }, []);
+    const triggerRadioChange = useCallback((value) => {
+        const handlers = radioChangeHandlersRef.current.get(value);
+        if (!handlers) {
+            return;
+        }
+        handlers.forEach((handler) => {
+            handler();
+        });
+    }, []);
+    const selectValue = useCallback((nextValue) => {
+        if (resolvedDisabled || !shouldDispatchGroupChange(selectedValue, nextValue)) {
+            return;
+        }
+        if (!hasCheckedRadio) {
+            setUncontrolledValue(nextValue);
+        }
+        onChange?.(toRadioGroupChangeEvent({ value: nextValue }, 'change', groupId));
+        triggerRadioChange(nextValue);
+    }, [groupId, hasCheckedRadio, onChange, resolvedDisabled, selectedValue, triggerRadioChange]);
+    const contextValue = useMemo(() => ({
+        groupId,
+        selectedValue,
+        disabled: resolvedDisabled,
+        selectValue,
+        registerRadioOnChange
+    }), [groupId, registerRadioOnChange, resolvedDisabled, selectValue, selectedValue]);
+    const lynxGroupProps = {
+        disabled: resolvedDisabled,
+        onValueChange: selectValue,
+        ...(selectedValue !== null ? { value: selectedValue } : {})
+    };
+    return (<RadioGroupRuntimeContext.Provider value={contextValue}>
+      <view {...mapped}>
+        <radio-group {...lynxGroupProps}>{children}</radio-group>
+      </view>
+    </RadioGroupRuntimeContext.Provider>);
+}
+let hasWarnedCheckedRadioValueMissing = false;
+function warnCheckedRadioValueMissing(missingValueCount) {
+    if (missingValueCount === 0 || isProduction() || hasWarnedCheckedRadioValueMissing) {
+        return;
+    }
+    hasWarnedCheckedRadioValueMissing = true;
+    // eslint-disable-next-line no-console
+    console.warn('[components-taro] Radio with checked=true inside RadioGroup requires a string value.');
+}
+function isProduction() {
+    return (globalThis.process?.env?.NODE_ENV === 'production');
+}
+//# sourceMappingURL=index.jsx.map

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

@@ -0,0 +1,44 @@
+import type { ReactNode } from '@byted-doubao-apps/framework';
+import type { RadioGroupProps as TaroRadioGroupProps } from '@tarojs/components';
+export type MappableTaroRadioGroupProps = Omit<TaroRadioGroupProps, 'children' | 'onChange'> & {
+    disabled?: boolean;
+};
+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 MapRadioGroupPropsResult = {
+    mapped: Record<string, unknown>;
+    unsupported: string[];
+    groupId: string;
+    resolvedDisabled: boolean;
+};
+type CheckedRadioSelection = {
+    hasCheckedRadio: boolean;
+    selectedValue: string | null;
+    missingValueCount: number;
+};
+export declare function mapRadioGroupProps(props: MappableTaroRadioGroupProps): MapRadioGroupPropsResult;
+export declare function resolveCheckedRadioSelection(children: ReactNode): CheckedRadioSelection;
+export declare function resolveGroupSelectedValue(hasCheckedRadio: boolean, checkedValue: string | null, uncontrolledValue: string | null): string | null;
+export declare function shouldDispatchGroupChange(currentValue: string | null, nextValue: string): boolean;
+export declare function toRadioGroupChangeEvent(detail: {
+    value: string;
+}, type: string, groupId: string): CommonEvent<{
+    value: string;
+}>;
+export {};
+//# sourceMappingURL=map.d.ts.map

package/dist/components/RadioGroup/map.js

@@ -0,0 +1,109 @@
+import { BASE_PROP_MAP } from '../base/prop-map.js';
+import { isRuntimeRadioElement } from '../Radio/shared.js';
+const RADIO_GROUP_PROP_MAP = {
+    name: null
+};
+export function mapRadioGroupProps(props) {
+    const { disabled, ...rest } = props;
+    const mapped = {};
+    const unsupported = [];
+    Object.entries(rest).forEach(([key, value]) => {
+        const target = RADIO_GROUP_PROP_MAP[key] ?? BASE_PROP_MAP[key];
+        if (target) {
+            mapped[target] = value;
+            return;
+        }
+        unsupported.push(key);
+    });
+    const resolvedDisabled = resolveBooleanProp(disabled, 'disabled', unsupported) ?? false;
+    return {
+        mapped,
+        unsupported: dedupe(unsupported),
+        groupId: resolveGroupId(mapped.id),
+        resolvedDisabled
+    };
+}
+export function resolveCheckedRadioSelection(children) {
+    const result = {
+        hasCheckedRadio: false,
+        selectedValue: null,
+        missingValueCount: 0
+    };
+    visitNode(children, result);
+    return result;
+}
+export function resolveGroupSelectedValue(hasCheckedRadio, checkedValue, uncontrolledValue) {
+    return hasCheckedRadio ? checkedValue : uncontrolledValue;
+}
+export function shouldDispatchGroupChange(currentValue, nextValue) {
+    return currentValue !== nextValue;
+}
+export function toRadioGroupChangeEvent(detail, type, groupId) {
+    return {
+        type,
+        timeStamp: Date.now(),
+        target: {
+            id: groupId,
+            tagName: 'radio-group',
+            dataset: {}
+        },
+        currentTarget: {
+            id: groupId,
+            tagName: 'radio-group',
+            dataset: {}
+        },
+        detail,
+        preventDefault: () => { },
+        stopPropagation: () => { }
+    };
+}
+function visitNode(node, result) {
+    if (node === null || node === undefined || typeof node === 'boolean') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        node.forEach((child) => visitNode(child, result));
+        return;
+    }
+    if (!isReactElement(node)) {
+        return;
+    }
+    const element = node;
+    const props = element.props ?? {};
+    if (isRuntimeRadioElement(element) && props.checked === true) {
+        result.hasCheckedRadio = true;
+        if (typeof props.value === 'string') {
+            if (result.selectedValue === null) {
+                result.selectedValue = props.value;
+            }
+        }
+        else {
+            result.missingValueCount += 1;
+        }
+    }
+    if (props.children !== undefined) {
+        visitNode(props.children, result);
+    }
+}
+function resolveBooleanProp(value, propName, unsupported) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    unsupported.push(propName);
+    return undefined;
+}
+function resolveGroupId(id) {
+    return typeof id === 'string' && id.length > 0 ? id : 'radio-group';
+}
+function dedupe(values) {
+    return Array.from(new Set(values));
+}
+function isReactElement(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.$$typeof === Symbol.for('react.element'));
+}
+//# sourceMappingURL=map.js.map

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

@@ -0,0 +1,3 @@
+import type { WebViewProps } from '@tarojs/components';
+export declare function WebView(props: WebViewProps): any;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/WebView/index.jsx

@@ -0,0 +1,24 @@
+function toCommonEvent(detail, type) {
+    return {
+        type,
+        timeStamp: Date.now(),
+        target: {
+            id: '',
+            tagName: 'web-view',
+            dataset: {}
+        },
+        currentTarget: {
+            id: '',
+            tagName: 'web-view',
+            dataset: {}
+        },
+        detail,
+        preventDefault: () => { },
+        stopPropagation: () => { }
+    };
+}
+export function WebView(props) {
+    const { src, onLoad, onError, onMessage } = props;
+    return (<web-view src={src} onLoad={() => onLoad?.(toCommonEvent({ src }, 'load'))} onError={(e) => onError?.(toCommonEvent({ src, errorMsg: e.errorMsg, errorCode: e.errorCode }, 'error'))} onMessage={(e) => onMessage?.(toCommonEvent({ data: [e.msg] }, 'message'))}/>);
+}
+//# sourceMappingURL=index.jsx.map

package/dist/components/index.d.ts

@@ -4,7 +4,11 @@ export * from './Text/index.jsx';
 export * from './Image/index.jsx';
 export * from './CoverImage/index.js';
 export * from './Input/index.jsx';
+export * from './Radio/index.jsx';
+export * from './RadioGroup/index.jsx';
 export * from './ScrollView/index.jsx';
 export * from './Map/index.jsx';
+export * from './WebView/index.jsx';
 export { Button, Slider, Swiper, SwiperItem, TextArea } from '@byted-doubao-apps/components';
+export * from './PickerView/index.jsx';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/index.js

@@ -4,7 +4,11 @@ export * from './Text/index.jsx';
 export * from './Image/index.jsx';
 export * from './CoverImage/index.js';
 export * from './Input/index.jsx';
+export * from './Radio/index.jsx';
+export * from './RadioGroup/index.jsx';
 export * from './ScrollView/index.jsx';
 export * from './Map/index.jsx';
+export * from './WebView/index.jsx';
 export { Button, Slider, Swiper, SwiperItem, TextArea } from '@byted-doubao-apps/components';
+export * from './PickerView/index.jsx';
 //# sourceMappingURL=index.js.map

package/dist/exports/app-core.d.ts

@@ -1,3 +1,3 @@
 export { useError, useLaunch, usePageNotFound, useDidHide, useDidShow } from '../hooks/lifecycle/app.js';
-export { request, getEnv, getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo } from './common.js';
+export * from './common.js';
 //# sourceMappingURL=app-core.d.ts.map

package/dist/exports/app-core.js

@@ -1,3 +1,3 @@
 export { useError, useLaunch, usePageNotFound, useDidHide, useDidShow } from '../hooks/lifecycle/app.js';
-export { request, getEnv, getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo } from './common.js';
+export * from './common.js';
 //# sourceMappingURL=app-core.js.map

package/dist/exports/view-core.d.ts

@@ -1,3 +1,3 @@
-export { request, getEnv, getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo, createMapContext } from './common.js';
+export * from './common.js';
 export { useCreated as useLoad, useMounted as useReady, useShow as useDidShow, useHide as useDidHide, useError, useDestroy as useUnload } from '@byted-doubao-apps/framework';
 //# sourceMappingURL=view-core.d.ts.map

package/dist/exports/view-core.js

@@ -1,3 +1,3 @@
-export { request, getEnv, getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo, createMapContext } from './common.js';
+export * from './common.js';
 export { useCreated as useLoad, useMounted as useReady, useShow as useDidShow, useHide as useDidHide, useError, useDestroy as useUnload } from '@byted-doubao-apps/framework';
 //# sourceMappingURL=view-core.js.map

package/dist/internal/map-context/index.d.ts

@@ -1,4 +1,5 @@
 import type { MapRef } from '@byted-doubao-apps/components';
+import type { MapProps } from '@tarojs/components';
 export interface MapPoint {
     latitude: number;
     longitude: number;
@@ -7,7 +8,11 @@ export interface MapBounds {
     northeast: MapPoint;
     southwest: MapPoint;
 }
-export type MapController = Pick<MapRef, 'getCenter' | 'setCenter' | 'getScale' | 'getBound' | 'fitPoints' | 'setAnchor'>;
+type BaseMapController = Pick<MapRef, 'getCenter' | 'setCenter' | 'getScale' | 'getBound' | 'fitPoints' | 'setAnchor'>;
+export interface MapController extends BaseMapController {
+    addMarkers: (markers: MapProps.marker[], clear?: boolean) => void;
+    removeMarkers: (markerIds: number[]) => void;
+}
 export declare const MAP_CONTEXT_METHOD_TO_COMPONENT_METHOD: {
     readonly getCenterLocation: "getCenter";
     readonly moveToLocation: "setCenter";
@@ -19,4 +24,5 @@ export declare const MAP_CONTEXT_METHOD_TO_COMPONENT_METHOD: {
 export declare function registerMapController(mapId: string, controller: MapController): void;
 export declare function unregisterMapController(mapId: string, controller?: MapController): void;
 export declare function getMapController(mapId: string): MapController | undefined;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -37,7 +37,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "0.0.18",
+  "version": "0.0.19",
   "scripts": {
     "dev": "npm run build -- -w",
     "build": "rimraf dist bundle && tsc -p tsconfig.build.json",