@lynx-js/web-mainthread-apis 0.13.4 → 0.14.0

package/dist/elementAPI/event/eventFunctions.js

@@ -1,142 +0,0 @@
-// Copyright 2023 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-import { componentIdAttribute, LynxEventNameToW3cByTagName, LynxEventNameToW3cCommon, lynxTagAttribute, W3cEventNameToLynx, } from '@lynx-js/web-constants';
-import { elementToRuntimeInfoMap, getElementByUniqueId, } from '../../MainThreadRuntime.js';
-import { createCrossThreadEvent } from '../../utils/createCrossThreadEvent.js';
-export function createEventFunctions(runtime) {
-    const btsHandler = (event) => {
-        if (!event.currentTarget) {
-            return;
-        }
-        const currentTarget = event.currentTarget;
-        const isCapture = event.eventPhase === Event.CAPTURING_PHASE;
-        const lynxEventName = W3cEventNameToLynx[event.type] ?? event.type;
-        const runtimeInfo = runtime[elementToRuntimeInfoMap].get(currentTarget);
-        const hname = isCapture
-            ? runtimeInfo.eventHandlerMap[lynxEventName]?.capture
-                ?.handler
-            : runtimeInfo.eventHandlerMap[lynxEventName]?.bind
-                ?.handler;
-        const crossThreadEvent = createCrossThreadEvent(runtime, event, lynxEventName);
-        if (typeof hname === 'string') {
-            const parentComponentUniqueId = runtimeInfo.parentComponentUniqueId;
-            const parentComponent = runtime[getElementByUniqueId](Number(parentComponentUniqueId));
-            const componentId = parentComponent?.getAttribute(lynxTagAttribute) !== 'page'
-                ? parentComponent?.getAttribute(componentIdAttribute) ?? undefined
-                : undefined;
-            if (componentId) {
-                runtime.config.callbacks.publicComponentEvent(componentId, hname, crossThreadEvent);
-            }
-            else {
-                runtime.config.callbacks.publishEvent(hname, crossThreadEvent);
-            }
-            return true;
-        }
-        else if (hname) {
-            crossThreadEvent.target.elementRefptr =
-                event.target;
-            if (crossThreadEvent.currentTarget) {
-                crossThreadEvent.currentTarget
-                    .elementRefptr = event.currentTarget;
-            }
-            runtime.runWorklet?.(hname.value, [crossThreadEvent]);
-        }
-        return false;
-    };
-    const btsCatchHandler = (event) => {
-        const handlerTriggered = btsHandler(event);
-        if (handlerTriggered)
-            event.stopPropagation();
-    };
-    function __AddEvent(element, eventType, eventName, newEventHandler) {
-        eventName = eventName.toLowerCase();
-        const isCatch = eventType === 'catchEvent' || eventType === 'capture-catch';
-        const isCapture = eventType.startsWith('capture');
-        const runtimeInfo = runtime[elementToRuntimeInfoMap].get(element);
-        const currentHandler = isCapture
-            ? runtimeInfo.eventHandlerMap[eventName]?.capture
-            : runtimeInfo.eventHandlerMap[eventName]?.bind;
-        const currentRegisteredHandler = isCatch ? btsCatchHandler : btsHandler;
-        if (currentHandler) {
-            if (!newEventHandler) {
-                /**
-                 * remove handler
-                 */
-                element.removeEventListener(eventName, currentRegisteredHandler, {
-                    capture: isCapture,
-                });
-            }
-        }
-        else {
-            /**
-             * append new handler
-             */
-            if (newEventHandler) {
-                const htmlEventName = LynxEventNameToW3cByTagName[element.tagName]?.[eventName]
-                    ?? LynxEventNameToW3cCommon[eventName] ?? eventName;
-                element.addEventListener(htmlEventName, currentRegisteredHandler, {
-                    capture: isCapture,
-                });
-            }
-        }
-        if (newEventHandler) {
-            const info = {
-                type: eventType,
-                handler: newEventHandler,
-            };
-            if (!runtimeInfo.eventHandlerMap[eventName]) {
-                runtimeInfo.eventHandlerMap[eventName] = {
-                    capture: undefined,
-                    bind: undefined,
-                };
-            }
-            if (isCapture) {
-                runtimeInfo.eventHandlerMap[eventName].capture = info;
-            }
-            else {
-                runtimeInfo.eventHandlerMap[eventName].bind = info;
-            }
-        }
-    }
-    function __GetEvent(element, eventName, eventType) {
-        const runtimeInfo = runtime[elementToRuntimeInfoMap].get(element);
-        eventName = eventName.toLowerCase();
-        const isCapture = eventType.startsWith('capture');
-        const handler = isCapture
-            ? runtimeInfo.eventHandlerMap[eventName]?.capture
-            : runtimeInfo.eventHandlerMap[eventName]?.bind;
-        return handler?.handler;
-    }
-    function __GetEvents(element) {
-        const eventHandlerMap = runtime[elementToRuntimeInfoMap].get(element).eventHandlerMap;
-        const eventInfos = [];
-        for (const [lynxEventName, info] of Object.entries(eventHandlerMap)) {
-            for (const atomInfo of [info.bind, info.capture]) {
-                if (atomInfo) {
-                    const { type, handler } = atomInfo;
-                    if (handler) {
-                        eventInfos.push({
-                            type: type,
-                            name: lynxEventName,
-                            function: handler,
-                        });
-                    }
-                }
-            }
-        }
-        return eventInfos;
-    }
-    function __SetEvents(element, listeners) {
-        for (const { type: eventType, name: lynxEventName, function: eventHandler } of listeners) {
-            __AddEvent(element, eventType, lynxEventName, eventHandler);
-        }
-    }
-    return {
-        __AddEvent,
-        __GetEvent,
-        __GetEvents,
-        __SetEvents,
-    };
-}
-//# sourceMappingURL=eventFunctions.js.map

package/dist/elementAPI/style/styleFunctions.d.ts

@@ -1,10 +0,0 @@
-import { type CssInJsInfo } from '@lynx-js/web-constants';
-import { type MainThreadRuntime } from '../../MainThreadRuntime.js';
-export declare function createStyleFunctions(runtime: MainThreadRuntime, cssInJsInfo: CssInJsInfo): {
-    __AddClass: (element: HTMLElement, className: string) => void;
-    __SetClasses: (element: HTMLElement, classNames: string | null) => void;
-    __GetClasses: (element: HTMLElement) => string[];
-    __AddInlineStyle: (element: HTMLElement, key: number | string, value: string | number | null | undefined) => void;
-    __SetInlineStyles: (element: HTMLElement, value: string | Record<string, string> | undefined) => void;
-    __SetCSSId: (elements: (HTMLElement)[], cssId: string | number) => void;
-};

package/dist/elementAPI/style/styleFunctions.js

@@ -1,89 +0,0 @@
-// Copyright 2023 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-import { cssIdAttribute } from '@lynx-js/web-constants';
-import hyphenateStyleName from 'hyphenate-style-name';
-import { queryCSSProperty } from './cssPropertyMap.js';
-import { decodeCssInJs } from '../../utils/decodeCssInJs.js';
-import { transformInlineStyleString, transformParsedStyles, } from './transformInlineStyle.js';
-import { elementToRuntimeInfoMap, updateCSSInJsStyle, } from '../../MainThreadRuntime.js';
-export function createStyleFunctions(runtime, cssInJsInfo) {
-    function __AddClass(element, className) {
-        const newClassName = ((element.className ?? '') + ' ' + className)
-            .trim();
-        element.setAttribute('class', newClassName);
-        if (!runtime.config.pageConfig.enableCSSSelector) {
-            const newStyleStr = decodeCssInJs(newClassName, cssInJsInfo, element.getAttribute(cssIdAttribute));
-            runtime[updateCSSInJsStyle](runtime[elementToRuntimeInfoMap].get(element).uniqueId, newStyleStr);
-        }
-    }
-    function __SetClasses(element, classNames) {
-        classNames
-            ? element.setAttribute('class', classNames)
-            : element.removeAttribute('class');
-        if (!runtime.config.pageConfig.enableCSSSelector) {
-            const newStyleStr = decodeCssInJs(classNames ?? '', cssInJsInfo, element.getAttribute(cssIdAttribute));
-            runtime[updateCSSInJsStyle](runtime[elementToRuntimeInfoMap].get(element).uniqueId, newStyleStr ?? '');
-        }
-    }
-    function __GetClasses(element) {
-        return (element.className ?? '').split(' ').filter(e => e);
-    }
-    function __AddInlineStyle(element, key, value) {
-        let dashName;
-        if (typeof key === 'number') {
-            const queryResult = queryCSSProperty(key);
-            dashName = queryResult.dashName;
-            if (queryResult.isX) {
-                console.error(`[lynx-web] css property: ${dashName} is not supported.`);
-            }
-        }
-        else {
-            dashName = key;
-        }
-        const valueStr = typeof value === 'number' ? value.toString() : value;
-        if (!valueStr) { // null or undefined
-            element.style.removeProperty(dashName);
-        }
-        else {
-            const { transformedStyle } = transformParsedStyles([[
-                    dashName,
-                    valueStr,
-                ]]);
-            for (const [property, value] of transformedStyle) {
-                element.style.setProperty(property, value);
-            }
-        }
-    }
-    function __SetInlineStyles(element, value) {
-        if (!value)
-            return;
-        const { transformedStyle } = typeof value === 'string'
-            ? transformInlineStyleString(value)
-            : transformParsedStyles(Object.entries(value).map(([k, value]) => [
-                hyphenateStyleName(k),
-                value,
-            ]));
-        const transformedStyleStr = transformedStyle.map(([property, value]) => `${property}:${value};`).join('');
-        element.setAttribute('style', transformedStyleStr);
-    }
-    function __SetCSSId(elements, cssId) {
-        cssId = cssId.toString();
-        for (const element of elements) {
-            element.setAttribute(cssIdAttribute, cssId);
-            if (!runtime.config.pageConfig.enableCSSSelector) {
-                const cls = element.getAttribute('class');
-                cls && __SetClasses(element, cls);
-            }
-        }
-    }
-    return {
-        __AddClass,
-        __SetClasses,
-        __GetClasses,
-        __AddInlineStyle,
-        __SetInlineStyles,
-        __SetCSSId,
-    };
-}
-//# sourceMappingURL=styleFunctions.js.map