@doubao-apps/taro-runtime 0.0.18 → 0.0.19

package/dist/api/base/index.d.ts

@@ -1,5 +1,17 @@
 export declare function getEnv(): TaroGeneral.ENV_TYPE | 'DOUBAO';
 export declare const ENV_TYPE: {
     DOUBAO: string;
+    WEAPP: string;
+    SWAN: string;
+    ALIPAY: string;
+    TT: string;
+    QQ: string;
+    JD: string;
+    WEB: string;
+    RN: string;
+    HARMONY: string;
+    QUICKAPP: string;
+    HARMONYHYBRID: string;
+    ASCF: string;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/api/base/index.js

@@ -2,6 +2,18 @@ export function getEnv() {
     return 'DOUBAO';
 }
 export const ENV_TYPE = {
-    DOUBAO: 'DOUBAO'
+    DOUBAO: 'DOUBAO',
+    WEAPP: 'WEAPP',
+    SWAN: 'SWAN',
+    ALIPAY: 'ALIPAY',
+    TT: 'TT',
+    QQ: 'QQ',
+    JD: 'JD',
+    WEB: 'WEB',
+    RN: 'RN',
+    HARMONY: 'HARMONY',
+    QUICKAPP: 'QUICKAPP',
+    HARMONYHYBRID: 'HARMONYHYBRID',
+    ASCF: 'ASCF'
 };
 //# sourceMappingURL=index.js.map

package/dist/api/create-selector-query/index.d.ts

@@ -0,0 +1,3 @@
+import type Taro from '@tarojs/taro';
+export declare function createSelectorQuery(): Taro.SelectorQuery;
+//# sourceMappingURL=index.d.ts.map

package/dist/api/create-selector-query/index.js

@@ -0,0 +1,577 @@
+import { getWindowInfo } from '../system/index.js';
+import { warnUnsupported } from '../../utils/warn-unsupported.js';
+const UNSUPPORTED_IN = 'createSelectorQuery.in(component)';
+const UNSUPPORTED_CONTEXT = 'createSelectorQuery.context()';
+const UNSUPPORTED_NODE = 'createSelectorQuery.node()';
+const UNSUPPORTED_FIELDS_COMPUTED_STYLE = 'createSelectorQuery.fields.computedStyle';
+const UNSUPPORTED_FIELDS_PROPERTIES = 'createSelectorQuery.fields.properties';
+const UNSUPPORTED_FIELDS_MARK = 'createSelectorQuery.fields.mark';
+const UNSUPPORTED_FIELDS_CONTEXT = 'createSelectorQuery.fields.context';
+const UNSUPPORTED_FIELDS_NODE = 'createSelectorQuery.fields.node';
+const UNSUPPORTED_VIEWPORT_SCROLL_OFFSET = 'createSelectorQuery.selectViewport().scrollOffset';
+const UNSUPPORTED_SCROLL_OFFSET = 'createSelectorQuery.scrollOffset (node is not a supported scroll container)';
+class SelectorQueryAdapter {
+    constructor() {
+        this.tasks = [];
+    }
+    select(selector) {
+        return new NodesRefAdapter(this, { kind: 'single', selector });
+    }
+    selectAll(selector) {
+        return new NodesRefAdapter(this, { kind: 'multi', selector });
+    }
+    selectViewport() {
+        return new NodesRefAdapter(this, { kind: 'viewport' });
+    }
+    in(_component) {
+        warnUnsupported(UNSUPPORTED_IN);
+        return this;
+    }
+    pushTask(task) {
+        this.tasks.push(task);
+    }
+    exec(callback) {
+        const pending = this.tasks.splice(0, this.tasks.length);
+        void (async () => {
+            const results = [];
+            for (const task of pending) {
+                const result = await task.run();
+                task.callback?.(result);
+                results.push(result);
+            }
+            callback?.(results);
+        })();
+        // Taro typings declare a NodesRef return value, but exec semantics are fire-and-forget.
+        return undefined;
+    }
+}
+class NodesRefAdapter {
+    constructor(query, target) {
+        this.query = query;
+        this.target = target;
+    }
+    boundingClientRect(callback) {
+        console.log('boundingClientRect', this.target);
+        this.query.pushTask({
+            run: () => resolveBoundingClientRect(this.target),
+            callback: callback
+        });
+        return this.query;
+    }
+    fields(fields, callback) {
+        this.query.pushTask({
+            run: () => resolveFields(this.target, fields ?? {}),
+            callback: callback
+        });
+        return this.query;
+    }
+    scrollOffset(callback) {
+        this.query.pushTask({
+            run: () => resolveScrollOffset(this.target),
+            callback: callback
+        });
+        return this.query;
+    }
+    context(callback) {
+        this.query.pushTask({
+            run: async () => resolveUnsupportedOperation(this.target, UNSUPPORTED_CONTEXT),
+            callback: callback
+        });
+        return this.query;
+    }
+    node(callback) {
+        this.query.pushTask({
+            run: async () => resolveUnsupportedOperation(this.target, UNSUPPORTED_NODE),
+            callback: callback
+        });
+        return this.query;
+    }
+}
+function getLynxRoot() {
+    return lynx;
+}
+async function resolveBoundingClientRect(target) {
+    if (target.kind === 'viewport') {
+        const rect = getViewportRect();
+        return createRectPayload(rect, '', {});
+    }
+    if (target.kind === 'single') {
+        const invokeResult = await runSingleInvoke(target.selector, 'boundingClientRect');
+        console.log('invokeResult', invokeResult);
+        if (invokeResult.selectorUnsupported) {
+            warnUnsupported(`createSelectorQuery selector unsupported: ${target.selector}`);
+            return null;
+        }
+        if (!invokeResult.data) {
+            return null;
+        }
+        const fieldsResult = await runSingleFields(target.selector, { id: true, dataset: true });
+        if (fieldsResult.selectorUnsupported) {
+            warnUnsupported(`createSelectorQuery selector unsupported: ${target.selector}`);
+        }
+        const id = fieldsResult.selectorUnsupported ? '' : toStringOrEmpty(fieldsResult.data?.id);
+        const dataset = fieldsResult.selectorUnsupported ? {} : toRecord(fieldsResult.data?.dataset);
+        return createRectPayload(invokeResult.data, id, dataset);
+    }
+    const fieldsResult = await runMultiFields(target.selector, { id: true, dataset: true, query: true });
+    if (fieldsResult.selectorUnsupported) {
+        warnUnsupported(`createSelectorQuery selector unsupported: ${target.selector}`);
+        return [];
+    }
+    if (fieldsResult.data.length === 0) {
+        return [];
+    }
+    const rectResults = await Promise.all(fieldsResult.data.map(async (item) => {
+        const query = item.query;
+        const invokeResult = await runInvokeFromQueryRoot(query, 'boundingClientRect');
+        if (!invokeResult.data) {
+            return null;
+        }
+        return createRectPayload(invokeResult.data, toStringOrEmpty(item.id), toRecord(item.dataset));
+    }));
+    return rectResults.filter((item) => item !== null);
+}
+async function resolveFields(target, fields) {
+    const hasUnsupportedFields = markUnsupportedFields(fields);
+    const wantsId = fields.id === true;
+    const wantsDataset = fields.dataset === true;
+    const wantsRect = fields.rect === true;
+    const wantsSize = fields.size === true;
+    const wantsScrollOffset = fields.scrollOffset === true;
+    const hasSupportedFields = wantsId || wantsDataset || wantsRect || wantsSize || wantsScrollOffset;
+    if (!hasSupportedFields) {
+        if (hasUnsupportedFields) {
+            return getEmptyResult(target);
+        }
+        return getEmptyResult(target);
+    }
+    if (target.kind === 'viewport') {
+        return resolveViewportFields(fields);
+    }
+    if (target.kind === 'single') {
+        const output = {};
+        const [baseResult, rectResult, scrollResult] = await Promise.all([
+            wantsId || wantsDataset
+                ? runSingleFields(target.selector, { id: true, dataset: true })
+                : Promise.resolve(null),
+            wantsRect || wantsSize ? runSingleInvoke(target.selector, 'boundingClientRect') : Promise.resolve(null),
+            wantsScrollOffset ? runSingleInvoke(target.selector, 'getScrollInfo') : Promise.resolve(null)
+        ]);
+        if (baseResult?.selectorUnsupported ||
+            rectResult?.selectorUnsupported ||
+            scrollResult?.selectorUnsupported) {
+            warnUnsupported(`createSelectorQuery selector unsupported: ${target.selector}`);
+            return null;
+        }
+        if (wantsId) {
+            output.id = toStringOrEmpty(baseResult?.data?.id);
+        }
+        if (wantsDataset) {
+            output.dataset = toRecord(baseResult?.data?.dataset);
+        }
+        if ((wantsRect || wantsSize) && rectResult?.data) {
+            const rect = createRectPayload(rectResult.data, toStringOrEmpty(baseResult?.data?.id), toRecord(baseResult?.data?.dataset));
+            if (wantsRect) {
+                output.left = rect.left;
+                output.right = rect.right;
+                output.top = rect.top;
+                output.bottom = rect.bottom;
+            }
+            if (wantsSize) {
+                output.width = rect.width;
+                output.height = rect.height;
+            }
+        }
+        if (wantsScrollOffset) {
+            if (scrollResult?.data) {
+                output.scrollLeft = toNumber(scrollResult.data.scrollLeft);
+                output.scrollTop = toNumber(scrollResult.data.scrollTop);
+            }
+            else {
+                warnUnsupported(UNSUPPORTED_SCROLL_OFFSET);
+            }
+        }
+        return Object.keys(output).length > 0 ? output : null;
+    }
+    const needsQuery = wantsRect || wantsSize || wantsScrollOffset;
+    const baseResult = await runMultiFields(target.selector, {
+        id: wantsId || wantsDataset || needsQuery,
+        dataset: wantsId || wantsDataset || needsQuery,
+        query: needsQuery
+    });
+    if (baseResult.selectorUnsupported) {
+        warnUnsupported(`createSelectorQuery selector unsupported: ${target.selector}`);
+        return [];
+    }
+    if (baseResult.data.length === 0) {
+        return [];
+    }
+    let hasScrollOffsetMiss = false;
+    const mapped = await Promise.all(baseResult.data.map(async (item) => {
+        const output = {};
+        if (wantsId) {
+            output.id = toStringOrEmpty(item.id);
+        }
+        if (wantsDataset) {
+            output.dataset = toRecord(item.dataset);
+        }
+        if (wantsRect || wantsSize) {
+            const rectResult = await runInvokeFromQueryRoot(item.query, 'boundingClientRect');
+            if (rectResult.data) {
+                const rect = createRectPayload(rectResult.data, toStringOrEmpty(item.id), toRecord(item.dataset));
+                if (wantsRect) {
+                    output.left = rect.left;
+                    output.right = rect.right;
+                    output.top = rect.top;
+                    output.bottom = rect.bottom;
+                }
+                if (wantsSize) {
+                    output.width = rect.width;
+                    output.height = rect.height;
+                }
+            }
+        }
+        if (wantsScrollOffset) {
+            const scrollResult = await runInvokeFromQueryRoot(item.query, 'getScrollInfo');
+            if (scrollResult.data) {
+                output.scrollLeft = toNumber(scrollResult.data.scrollLeft);
+                output.scrollTop = toNumber(scrollResult.data.scrollTop);
+            }
+            else {
+                hasScrollOffsetMiss = true;
+            }
+        }
+        return output;
+    }));
+    if (wantsScrollOffset && hasScrollOffsetMiss) {
+        warnUnsupported(UNSUPPORTED_SCROLL_OFFSET);
+    }
+    return mapped;
+}
+async function resolveScrollOffset(target) {
+    if (target.kind === 'viewport') {
+        warnUnsupported(UNSUPPORTED_VIEWPORT_SCROLL_OFFSET);
+        return {
+            id: '',
+            dataset: {},
+            scrollLeft: 0,
+            scrollTop: 0
+        };
+    }
+    if (target.kind === 'single') {
+        const [fieldsResult, invokeResult] = await Promise.all([
+            runSingleFields(target.selector, { id: true, dataset: true }),
+            runSingleInvoke(target.selector, 'getScrollInfo')
+        ]);
+        if (fieldsResult.selectorUnsupported || invokeResult.selectorUnsupported) {
+            warnUnsupported(`createSelectorQuery selector unsupported: ${target.selector}`);
+            return null;
+        }
+        if (!invokeResult.data) {
+            warnUnsupported(UNSUPPORTED_SCROLL_OFFSET);
+            return null;
+        }
+        return {
+            id: toStringOrEmpty(fieldsResult.data?.id),
+            dataset: toRecord(fieldsResult.data?.dataset),
+            scrollLeft: toNumber(invokeResult.data.scrollLeft),
+            scrollTop: toNumber(invokeResult.data.scrollTop)
+        };
+    }
+    const fieldsResult = await runMultiFields(target.selector, { id: true, dataset: true, query: true });
+    if (fieldsResult.selectorUnsupported) {
+        warnUnsupported(`createSelectorQuery selector unsupported: ${target.selector}`);
+        return [];
+    }
+    if (fieldsResult.data.length === 0) {
+        return [];
+    }
+    let hasMiss = false;
+    const results = await Promise.all(fieldsResult.data.map(async (item) => {
+        const invokeResult = await runInvokeFromQueryRoot(item.query, 'getScrollInfo');
+        if (!invokeResult.data) {
+            hasMiss = true;
+            return null;
+        }
+        return {
+            id: toStringOrEmpty(item.id),
+            dataset: toRecord(item.dataset),
+            scrollLeft: toNumber(invokeResult.data.scrollLeft),
+            scrollTop: toNumber(invokeResult.data.scrollTop)
+        };
+    }));
+    if (hasMiss) {
+        warnUnsupported(UNSUPPORTED_SCROLL_OFFSET);
+    }
+    return results.filter((item) => item !== null);
+}
+function resolveUnsupportedOperation(target, feature) {
+    warnUnsupported(feature);
+    return getEmptyResult(target);
+}
+function resolveViewportFields(fields) {
+    const output = {};
+    const rect = getViewportRect();
+    if (fields.id === true) {
+        output.id = '';
+    }
+    if (fields.dataset === true) {
+        output.dataset = {};
+    }
+    if (fields.rect === true) {
+        output.left = rect.left;
+        output.right = rect.right;
+        output.top = rect.top;
+        output.bottom = rect.bottom;
+    }
+    if (fields.size === true) {
+        output.width = rect.width;
+        output.height = rect.height;
+    }
+    if (fields.scrollOffset === true) {
+        warnUnsupported(UNSUPPORTED_VIEWPORT_SCROLL_OFFSET);
+        output.scrollLeft = 0;
+        output.scrollTop = 0;
+        if (fields.id !== true) {
+            output.id = '';
+        }
+        if (fields.dataset !== true) {
+            output.dataset = {};
+        }
+    }
+    return Object.keys(output).length > 0 ? output : null;
+}
+function markUnsupportedFields(fields) {
+    let hasUnsupported = false;
+    if (Array.isArray(fields.computedStyle) && fields.computedStyle.length > 0) {
+        hasUnsupported = true;
+        warnUnsupported(UNSUPPORTED_FIELDS_COMPUTED_STYLE);
+    }
+    if (Array.isArray(fields.properties) && fields.properties.length > 0) {
+        hasUnsupported = true;
+        warnUnsupported(UNSUPPORTED_FIELDS_PROPERTIES);
+    }
+    if (fields.mark === true) {
+        hasUnsupported = true;
+        warnUnsupported(UNSUPPORTED_FIELDS_MARK);
+    }
+    if (fields.context === true) {
+        hasUnsupported = true;
+        warnUnsupported(UNSUPPORTED_FIELDS_CONTEXT);
+    }
+    if (fields.node === true) {
+        hasUnsupported = true;
+        warnUnsupported(UNSUPPORTED_FIELDS_NODE);
+    }
+    return hasUnsupported;
+}
+function getViewportRect() {
+    const info = getWindowInfo();
+    const width = toNumber(info.windowWidth, toNumber(info.screenWidth));
+    const height = toNumber(info.windowHeight, toNumber(info.screenHeight));
+    return {
+        left: 0,
+        top: 0,
+        right: width,
+        bottom: height,
+        width,
+        height
+    };
+}
+function createRectPayload(rectLike, id, dataset) {
+    const left = toNumber(rectLike.left);
+    const top = toNumber(rectLike.top);
+    const width = toNumber(rectLike.width);
+    const height = toNumber(rectLike.height);
+    const right = toNumber(rectLike.right, left + width);
+    const bottom = toNumber(rectLike.bottom, top + height);
+    return {
+        id,
+        dataset,
+        left,
+        right,
+        top,
+        bottom,
+        width,
+        height
+    };
+}
+function getEmptyResult(target) {
+    return target.kind === 'multi' ? [] : null;
+}
+async function runSingleFields(selector, fields) {
+    const lynx = getLynxRoot();
+    if (!lynx) {
+        return { data: null, selectorUnsupported: false };
+    }
+    return new Promise((resolve) => {
+        try {
+            lynx
+                .createSelectorQuery()
+                .select(selector)
+                .fields(fields, (data, status) => {
+                resolve({
+                    data: data ?? null,
+                    selectorUnsupported: isSelectorUnsupported(status)
+                });
+            })
+                .exec();
+        }
+        catch (error) {
+            resolve({
+                data: null,
+                selectorUnsupported: isSelectorUnsupported(error)
+            });
+        }
+    });
+}
+async function runMultiFields(selector, fields) {
+    const lynx = getLynxRoot();
+    if (!lynx) {
+        return { data: [], selectorUnsupported: false };
+    }
+    return new Promise((resolve) => {
+        try {
+            lynx
+                .createSelectorQuery()
+                .selectAll(selector)
+                .fields(fields, (data, status) => {
+                resolve({
+                    data: Array.isArray(data) ? data : [],
+                    selectorUnsupported: isSelectorUnsupported(status)
+                });
+            })
+                .exec();
+        }
+        catch (error) {
+            resolve({
+                data: [],
+                selectorUnsupported: isSelectorUnsupported(error)
+            });
+        }
+    });
+}
+async function runSingleInvoke(selector, method, params) {
+    const lynx = getLynxRoot();
+    if (!lynx) {
+        return { data: null, selectorUnsupported: false };
+    }
+    return new Promise((resolve) => {
+        try {
+            lynx
+                .createSelectorQuery()
+                .select(selector)
+                .invoke({
+                method,
+                params,
+                success: (res) => {
+                    resolve({
+                        data: toRecordOrNull(res),
+                        selectorUnsupported: false
+                    });
+                },
+                fail: (error) => {
+                    resolve({
+                        data: null,
+                        selectorUnsupported: isSelectorUnsupported(error)
+                    });
+                }
+            })
+                .exec();
+        }
+        catch (error) {
+            resolve({
+                data: null,
+                selectorUnsupported: isSelectorUnsupported(error)
+            });
+        }
+    });
+}
+async function runInvokeFromQueryRoot(query, method, params) {
+    if (!query) {
+        return { data: null, selectorUnsupported: false };
+    }
+    return new Promise((resolve) => {
+        try {
+            query
+                .selectRoot()
+                .invoke({
+                method,
+                params,
+                success: (res) => {
+                    resolve({
+                        data: toRecordOrNull(res),
+                        selectorUnsupported: false
+                    });
+                },
+                fail: (error) => {
+                    resolve({
+                        data: null,
+                        selectorUnsupported: isSelectorUnsupported(error)
+                    });
+                }
+            })
+                .exec();
+        }
+        catch (error) {
+            resolve({
+                data: null,
+                selectorUnsupported: isSelectorUnsupported(error)
+            });
+        }
+    });
+}
+function isSelectorUnsupported(source) {
+    const code = extractCode(source);
+    if (code === 5) {
+        return true;
+    }
+    const text = extractMessage(source);
+    if (!text) {
+        return false;
+    }
+    return /selector/i.test(text) && /(not\s+support|unsupported)/i.test(text);
+}
+function extractCode(source) {
+    if (!source || typeof source !== 'object') {
+        return null;
+    }
+    const code = source.code;
+    if (typeof code === 'number' && Number.isFinite(code)) {
+        return code;
+    }
+    return null;
+}
+function extractMessage(source) {
+    if (typeof source === 'string') {
+        return source;
+    }
+    if (!source || typeof source !== 'object') {
+        return '';
+    }
+    const data = source.data;
+    if (typeof data === 'string') {
+        return data;
+    }
+    const message = source.message;
+    if (typeof message === 'string') {
+        return message;
+    }
+    return '';
+}
+function toNumber(value, fallback = 0) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function toStringOrEmpty(value) {
+    return typeof value === 'string' ? value : '';
+}
+function toRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function toRecordOrNull(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+export function createSelectorQuery() {
+    return new SelectorQueryAdapter();
+}
+//# sourceMappingURL=index.js.map

package/dist/api/index.d.ts

@@ -1,6 +1,10 @@
-export { getEnv } from './base/index.js';
+export { getEnv, ENV_TYPE } from './base/index.js';
 export { request } from './request/index.js';
-export { navigateTo } from './navigate/index.js';
-export { getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo } from './system/index.js';
+export { navigateBack, navigateTo, redirectTo } from './router/index.js';
+export { setStorage, setStorageSync, getStorage, getStorageSync, removeStorage, removeStorageSync, clearStorage, clearStorageSync, getStorageInfo, getStorageInfoSync } from './storage/index.js';
+export { getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo, makePhoneCall, getNetworkType } from './system/index.js';
+export { getLocation } from './location/index.js';
+export { showToast } from './show-toast/index.js';
 export { createMapContext } from './map/index.js';
+export { createSelectorQuery } from './create-selector-query/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.js

@@ -1,6 +1,10 @@
-export { getEnv } from './base/index.js';
+export { getEnv, ENV_TYPE } from './base/index.js';
 export { request } from './request/index.js';
-export { navigateTo } from './navigate/index.js';
-export { getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo } from './system/index.js';
+export { navigateBack, navigateTo, redirectTo } from './router/index.js';
+export { setStorage, setStorageSync, getStorage, getStorageSync, removeStorage, removeStorageSync, clearStorage, clearStorageSync, getStorageInfo, getStorageInfoSync } from './storage/index.js';
+export { getSystemSetting, getAppAuthorizeSetting, getDeviceInfo, getAppBaseInfo, getWindowInfo, makePhoneCall, getNetworkType } from './system/index.js';
+export { getLocation } from './location/index.js';
+export { showToast } from './show-toast/index.js';
 export { createMapContext } from './map/index.js';
+export { createSelectorQuery } from './create-selector-query/index.js';
 //# sourceMappingURL=index.js.map

package/dist/api/location/index.d.ts

@@ -0,0 +1,10 @@
+import type { GetLocationParams } from '@byted-doubao-apps/framework/api';
+import type { getLocation as taroGetLocation } from '@tarojs/taro';
+type TaroGetLocationOption = Parameters<typeof taroGetLocation>[0];
+type TaroGetLocationResult = Awaited<ReturnType<typeof taroGetLocation>>;
+type RuntimeGetLocationOption = TaroGetLocationOption & Partial<Pick<GetLocationParams, 'source' | 'mode' | 'timeoutMs' | 'maxCacheMs'>> & {
+    cacheTimeout?: number;
+};
+export declare function getLocation(option?: RuntimeGetLocationOption): Promise<TaroGetLocationResult>;
+export {};
+//# sourceMappingURL=index.d.ts.map