@lynx-js/testing-environment 0.1.0

package/dist/index.js

@@ -0,0 +1,283 @@
+import * as __WEBPACK_EXTERNAL_MODULE_events__ from "events";
+import * as __WEBPACK_EXTERNAL_MODULE__lynx_GlobalThis_js_9774bdf8__ from "./lynx/GlobalThis.js";
+import * as __WEBPACK_EXTERNAL_MODULE__lynx_ElementPAPI_js_053942f3__ from "./lynx/ElementPAPI.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function __injectElementApi(target) {
+    const elementTree = (0, __WEBPACK_EXTERNAL_MODULE__lynx_ElementPAPI_js_053942f3__.initElementTree)();
+    target.elementTree = elementTree;
+    if (void 0 === target) target = globalThis;
+    for (const k of Object.getOwnPropertyNames(elementTree.constructor.prototype))if (k.startsWith('__')) target[k] = elementTree[k].bind(elementTree);
+    target.$kTemplateAssembler = {};
+    target.registerDataProcessor = ()=>{
+        console.error('registerDataProcessor is not implemented');
+    };
+    target.__OnLifecycleEvent = (...args)=>{
+        const isMainThread = __MAIN_THREAD__;
+        globalThis.lynxTestingEnv.switchToBackgroundThread();
+        globalThis.lynxCoreInject.tt.OnLifecycleEvent(...args);
+        if (isMainThread) globalThis.lynxTestingEnv.switchToMainThread();
+    };
+    target._ReportError = ()=>{};
+}
+function createPolyfills() {
+    const app = {
+        callLepusMethod: (...rLynxChange)=>{
+            const isBackground = !__MAIN_THREAD__;
+            globalThis.lynxTestingEnv.switchToMainThread();
+            globalThis[rLynxChange[0]](rLynxChange[1]);
+            globalThis.lynxTestingEnv.switchToBackgroundThread();
+            rLynxChange[2]();
+            globalThis.lynxTestingEnv.switchToMainThread();
+            if (isBackground) globalThis.lynxTestingEnv.switchToBackgroundThread();
+        },
+        markTiming: ()=>{},
+        createJSObjectDestructionObserver: ()=>({})
+    };
+    const performance = {
+        __functionCallHistory: [],
+        _generatePipelineOptions: ()=>{
+            performance.__functionCallHistory.push([
+                '_generatePipelineOptions'
+            ]);
+            return {
+                pipelineID: 'pipelineID',
+                needTimestamps: false
+            };
+        },
+        _onPipelineStart: (id)=>{
+            performance.__functionCallHistory.push([
+                '_onPipelineStart',
+                id
+            ]);
+        },
+        _markTiming: (id, key)=>{
+            performance.__functionCallHistory.push([
+                '_markTiming',
+                id,
+                key
+            ]);
+        },
+        _bindPipelineIdWithTimingFlag: (id, flag)=>{
+            performance.__functionCallHistory.push([
+                '_bindPipelineIdWithTimingFlag',
+                id,
+                flag
+            ]);
+        }
+    };
+    const ee = new __WEBPACK_EXTERNAL_MODULE_events__["default"]();
+    ee.dispatchEvent = ({ type, data })=>{
+        const isMainThread = __MAIN_THREAD__;
+        lynxTestingEnv.switchToBackgroundThread();
+        ee.emit(type, {
+            data: data
+        });
+        if (isMainThread) lynxTestingEnv.switchToMainThread();
+    };
+    ee.addEventListener = ee.addListener;
+    ee.removeEventListener = ee.removeListener;
+    const CoreContext = ee;
+    const JsContext = ee;
+    function __LoadLepusChunk(chunkName, options) {
+        const isBackground = !__MAIN_THREAD__;
+        globalThis.lynxTestingEnv.switchToMainThread();
+        if (process.env['DEBUG']) console.log('__LoadLepusChunk', chunkName, options);
+        let ans;
+        if ('worklet-runtime' === chunkName) {
+            var _globalThis_onInitWorkletRuntime, _globalThis;
+            ans = null == (_globalThis_onInitWorkletRuntime = (_globalThis = globalThis).onInitWorkletRuntime) ? void 0 : _globalThis_onInitWorkletRuntime.call(_globalThis);
+        } else throw new Error(`__LoadLepusChunk: Unknown chunk name: ${chunkName}`);
+        if (isBackground) globalThis.lynxTestingEnv.switchToBackgroundThread();
+        return ans;
+    }
+    return {
+        app,
+        performance,
+        CoreContext,
+        JsContext,
+        __LoadLepusChunk
+    };
+}
+function injectMainThreadGlobals(target, polyfills) {
+    var _globalThis_onInjectMainThreadGlobals, _globalThis;
+    __injectElementApi(target);
+    const { performance, JsContext, __LoadLepusChunk } = polyfills || {};
+    if (void 0 === target) target = globalThis;
+    target.__DEV__ = true;
+    target.__PROFILE__ = true;
+    target.__JS__ = false;
+    target.__LEPUS__ = true;
+    target.__BACKGROUND__ = false;
+    target.__MAIN_THREAD__ = true;
+    target.__REF_FIRE_IMMEDIATELY__ = false;
+    target.__FIRST_SCREEN_SYNC_TIMING__ = 'immediately';
+    target.__TESTING_FORCE_RENDER_TO_OPCODE__ = false;
+    target.__ENABLE_SSR__ = false;
+    target.globDynamicComponentEntry = '__Card__';
+    target.lynx = {
+        performance,
+        getJSContext: ()=>JsContext,
+        reportError: (e)=>{
+            throw e;
+        }
+    };
+    target.requestAnimationFrame = setTimeout;
+    target.cancelAnimationFrame = clearTimeout;
+    target.console.profile = ()=>{};
+    target.console.profileEnd = ()=>{};
+    target.__LoadLepusChunk = __LoadLepusChunk;
+    null == (_globalThis_onInjectMainThreadGlobals = (_globalThis = globalThis).onInjectMainThreadGlobals) || _globalThis_onInjectMainThreadGlobals.call(_globalThis, target);
+}
+const IGNORE_LIST_GLOBALS = [
+    'globalThis',
+    'global'
+];
+class NodesRef {
+    invoke() {
+        throw new Error('not implemented');
+    }
+    path() {
+        throw new Error('not implemented');
+    }
+    fields() {
+        throw new Error('not implemented');
+    }
+    setNativeProps() {
+        throw new Error('not implemented');
+    }
+    constructor(selectorQuery, nodeSelectToken){
+        _define_property(this, "_nodeSelectToken", void 0);
+        _define_property(this, "_selectorQuery", void 0);
+        this._nodeSelectToken = nodeSelectToken;
+        this._selectorQuery = selectorQuery;
+    }
+}
+function injectBackgroundThreadGlobals(target, polyfills) {
+    var _globalThis_onInjectBackgroundThreadGlobals, _globalThis;
+    const { app, performance, CoreContext, __LoadLepusChunk } = polyfills || {};
+    if (void 0 === target) target = globalThis;
+    target.__DEV__ = true;
+    target.__PROFILE__ = true;
+    target.__JS__ = true;
+    target.__LEPUS__ = false;
+    target.__BACKGROUND__ = true;
+    target.__MAIN_THREAD__ = false;
+    target.__ENABLE_SSR__ = false;
+    target.globDynamicComponentEntry = '__Card__';
+    target.lynxCoreInject = {};
+    target.lynxCoreInject.tt = {
+        _params: {
+            initData: {},
+            updateData: {}
+        }
+    };
+    const globalEventEmitter = new __WEBPACK_EXTERNAL_MODULE_events__["default"]();
+    globalEventEmitter.trigger = globalEventEmitter.emit;
+    globalEventEmitter.toggle = globalEventEmitter.emit;
+    target.lynx = {
+        getNativeApp: ()=>app,
+        performance,
+        createSelectorQuery: ()=>({
+                selectUniqueID: function(uniqueId) {
+                    return new NodesRef({}, {
+                        type: 2,
+                        identifier: uniqueId.toString()
+                    });
+                }
+            }),
+        getCoreContext: ()=>CoreContext,
+        getJSModule: (moduleName)=>{
+            if ('GlobalEventEmitter' === moduleName) return globalEventEmitter;
+            throw new Error(`getJSModule(${moduleName}) not implemented`);
+        },
+        reportError: (e)=>{
+            throw e;
+        }
+    };
+    target.requestAnimationFrame = setTimeout;
+    target.cancelAnimationFrame = clearTimeout;
+    target.console.profile = ()=>{};
+    target.console.profileEnd = ()=>{};
+    target.SystemInfo = {
+        platform: 'iOS',
+        pixelRatio: 3,
+        pixelWidth: 1170,
+        pixelHeight: 2532,
+        osVersion: '17.0.2',
+        enableKrypton: true,
+        runtimeType: 'quickjs',
+        lynxSdkVersion: '3.0'
+    };
+    target.__LoadLepusChunk = __LoadLepusChunk;
+    null == (_globalThis_onInjectBackgroundThreadGlobals = (_globalThis = globalThis).onInjectBackgroundThreadGlobals) || _globalThis_onInjectBackgroundThreadGlobals.call(_globalThis, target);
+}
+class LynxTestingEnv {
+    injectGlobals() {
+        const polyfills = createPolyfills();
+        injectBackgroundThreadGlobals(this.backgroundThread.globalThis, polyfills);
+        injectMainThreadGlobals(this.mainThread.globalThis, polyfills);
+    }
+    switchToBackgroundThread() {
+        var _globalThis_onSwitchedToBackgroundThread, _globalThis;
+        this.originals = new Map();
+        Object.getOwnPropertyNames(this.backgroundThread.globalThis).forEach((key)=>{
+            if (IGNORE_LIST_GLOBALS.includes(key)) return;
+            this.originals.set(key, global[key]);
+            global[key] = this.backgroundThread.globalThis[key];
+        });
+        null == (_globalThis = globalThis) || null == (_globalThis_onSwitchedToBackgroundThread = _globalThis.onSwitchedToBackgroundThread) || _globalThis_onSwitchedToBackgroundThread.call(_globalThis);
+    }
+    switchToMainThread() {
+        var _globalThis_onSwitchedToMainThread, _globalThis;
+        this.originals = new Map();
+        Object.getOwnPropertyNames(this.mainThread.globalThis).forEach((key)=>{
+            if (IGNORE_LIST_GLOBALS.includes(key)) return;
+            this.originals.set(key, global[key]);
+            global[key] = this.mainThread.globalThis[key];
+        });
+        null == (_globalThis = globalThis) || null == (_globalThis_onSwitchedToMainThread = _globalThis.onSwitchedToMainThread) || _globalThis_onSwitchedToMainThread.call(_globalThis);
+    }
+    clearGlobal() {
+        var _this_originals, _this_originals1;
+        null == (_this_originals = this.originals) || _this_originals.forEach((v, k)=>{
+            global[k] = v;
+        });
+        null == (_this_originals1 = this.originals) || _this_originals1.clear();
+    }
+    reset() {
+        var _globalThis_onResetLynxTestingEnv, _globalThis;
+        this.injectGlobals();
+        this.switchToMainThread();
+        this.switchToBackgroundThread();
+        null == (_globalThis_onResetLynxTestingEnv = (_globalThis = globalThis).onResetLynxTestingEnv) || _globalThis_onResetLynxTestingEnv.call(_globalThis);
+    }
+    constructor(){
+        _define_property(this, "originals", new Map());
+        _define_property(this, "backgroundThread", void 0);
+        _define_property(this, "mainThread", void 0);
+        _define_property(this, "jsdom", global.jsdom);
+        this.backgroundThread = (0, __WEBPACK_EXTERNAL_MODULE__lynx_GlobalThis_js_9774bdf8__.createGlobalThis)();
+        this.mainThread = (0, __WEBPACK_EXTERNAL_MODULE__lynx_GlobalThis_js_9774bdf8__.createGlobalThis)();
+        const globalPolyfills = {
+            console: this.jsdom.window['console'],
+            Event: this.jsdom.window.Event,
+            window: this.jsdom.window,
+            document: this.jsdom.window.document
+        };
+        Object.assign(this.mainThread.globalThis, globalPolyfills);
+        Object.assign(this.backgroundThread.globalThis, globalPolyfills);
+        this.injectGlobals();
+        this.switchToBackgroundThread();
+    }
+}
+var __webpack_exports__initElementTree = __WEBPACK_EXTERNAL_MODULE__lynx_ElementPAPI_js_053942f3__.initElementTree;
+export { LynxTestingEnv, __webpack_exports__initElementTree as initElementTree };

package/dist/lynx/ElementPAPI.cjs

@@ -0,0 +1,264 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initElementTree: ()=>initElementTree
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const initElementTree = ()=>{
+    let uiSignNext = 0;
+    const uniqueId2Element = new Map();
+    return new class {
+        countElement(element, parentComponentUniqueId) {
+            element.$$uiSign = uiSignNext++;
+            uniqueId2Element.set(element.$$uiSign, element);
+            element.parentComponentUniqueId = parentComponentUniqueId;
+        }
+        __CreatePage(_tag, parentComponentUniqueId) {
+            const page = this.__CreateElement('page', parentComponentUniqueId);
+            this.root = page;
+            lynxTestingEnv.jsdom.window.document.body.appendChild(page);
+            return page;
+        }
+        __CreateRawText(text) {
+            const element = lynxTestingEnv.jsdom.window.document.createTextNode(text);
+            this.countElement(element, 0);
+            return element;
+        }
+        __GetElementUniqueID(e) {
+            return e.$$uiSign;
+        }
+        __SetClasses(e, cls) {
+            e.className = cls;
+        }
+        __CreateElement(tag, parentComponentUniqueId) {
+            if ('raw-text' === tag) return this.__CreateRawText('');
+            const element = lynxTestingEnv.jsdom.window.document.createElement(tag);
+            this.countElement(element, parentComponentUniqueId);
+            return element;
+        }
+        __CreateView(parentComponentUniqueId) {
+            return this.__CreateElement('view', parentComponentUniqueId);
+        }
+        __CreateScrollView(parentComponentUniqueId) {
+            return this.__CreateElement('scroll-view', parentComponentUniqueId);
+        }
+        __FirstElement(e) {
+            return e.firstChild;
+        }
+        __CreateText(parentComponentUniqueId) {
+            return this.__CreateElement('text', parentComponentUniqueId);
+        }
+        __CreateImage(parentComponentUniqueId) {
+            return this.__CreateElement('image', parentComponentUniqueId);
+        }
+        __CreateWrapperElement(parentComponentUniqueId) {
+            return this.__CreateElement('wrapper', parentComponentUniqueId);
+        }
+        __AddInlineStyle(e, key, value) {
+            e.style[key] = value;
+        }
+        __AppendElement(parent, child) {
+            parent.appendChild(child);
+        }
+        __SetCSSId(e, id, entryName) {
+            const cssId = `${entryName ?? '__Card__'}:${id}`;
+            if (Array.isArray(e)) e.forEach((item)=>{
+                item.cssId = cssId;
+            });
+            else e.cssId = cssId;
+        }
+        __SetAttribute(e, key, value) {
+            if ('style' === key || 'class' === key || 'className' === key || 'key' === key || 'id' === key || 'ref' === key || /^data-/.exec(key) || /^(bind|catch|global-bind|capture-bind|capture-catch)[A-Za-z]/.exec(key)) throw new Error(`Cannot use __SetAttribute for "${key}"`);
+            if ('update-list-info' === key) {
+                let listInfoStr = e.getAttribute(key);
+                let listInfo = listInfoStr ? JSON.parse(listInfoStr) : [];
+                listInfo.push(value);
+                e.setAttribute(key, JSON.stringify(listInfo));
+                return;
+            }
+            if ('text' === key) {
+                e.textContent = value;
+                return;
+            }
+            if (null === value) return void e.removeAttribute(key);
+            if ('string' == typeof value) return void e.setAttribute(key, value);
+            e.setAttribute(key, JSON.stringify(value));
+        }
+        __AddEvent(e, eventType, eventName, eventHandler) {
+            var _e_eventMap;
+            if (null == (_e_eventMap = e.eventMap) ? void 0 : _e_eventMap[`${eventType}:${eventName}`]) {
+                e.removeEventListener(`${eventType}:${eventName}`, e.eventMap[`${eventType}:${eventName}`]);
+                delete e.eventMap[`${eventType}:${eventName}`];
+            }
+            if (void 0 === eventHandler) return;
+            if ('string' != typeof eventHandler && void 0 === eventHandler['type']) throw new Error(`event must be string, but got ${typeof eventHandler}`);
+            const listener = (evt)=>{
+                if ('object' == typeof eventHandler && 'worklet' === eventHandler['type']) {
+                    const isBackground = !__MAIN_THREAD__;
+                    globalThis.lynxTestingEnv.switchToMainThread();
+                    runWorklet(eventHandler.value, [
+                        Object.assign({}, evt)
+                    ]);
+                    if (isBackground) globalThis.lynxTestingEnv.switchToBackgroundThread();
+                } else {
+                    if ('catchEvent' === eventType || 'capture-catch' === eventType) evt.stopPropagation();
+                    globalThis.lynxCoreInject.tt.publishEvent(eventHandler, evt);
+                }
+            };
+            e.eventMap = e.eventMap ?? {};
+            e.eventMap[`${eventType}:${eventName}`] = listener;
+            e.addEventListener(`${eventType}:${eventName}`, listener, {
+                capture: 'capture-bind' === eventType || 'capture-catch' === eventType
+            });
+        }
+        __GetEvent(e, eventType, eventName) {
+            var _e_eventMap;
+            const jsFunction = null == (_e_eventMap = e.eventMap) ? void 0 : _e_eventMap[`${eventType}:${eventName}`];
+            if (void 0 !== jsFunction) return {
+                type: eventType,
+                name: eventName,
+                jsFunction
+            };
+        }
+        __SetID(e, id) {
+            e.id = id;
+        }
+        __SetInlineStyles(e, styles) {
+            if ('string' == typeof styles) e.style.cssText = styles;
+            else Object.assign(e.style, styles);
+        }
+        __AddDataset(e, key, value) {
+            e.dataset[key] = value;
+        }
+        __SetDataset(e, dataset) {
+            Object.assign(e.dataset, dataset);
+        }
+        __SetGestureDetector(e, id, type, config, relationMap) {
+            e.gesture = {
+                id,
+                type,
+                config,
+                relationMap
+            };
+        }
+        __GetDataset(e) {
+            return e.dataset;
+        }
+        __RemoveElement(parent, child) {
+            let ch = parent.firstChild;
+            while(ch)if (ch === child) {
+                parent.removeChild(ch);
+                break;
+            }
+        }
+        __InsertElementBefore(parent, child, ref) {
+            if (void 0 === ref) parent.appendChild(child);
+            else parent.insertBefore(child, ref);
+        }
+        __ReplaceElement(newElement, oldElement) {
+            const parent = oldElement.parentNode;
+            if (!parent) throw new Error('unreachable');
+            parent.replaceChild(newElement, oldElement);
+        }
+        __FlushElementTree() {}
+        __UpdateListComponents(_list, _components) {}
+        __UpdateListCallbacks(list, componentAtIndex, enqueueComponent) {
+            Object.defineProperties(list, {
+                componentAtIndex: {
+                    enumerable: false,
+                    configurable: true,
+                    value: componentAtIndex
+                },
+                enqueueComponent: {
+                    enumerable: false,
+                    configurable: true,
+                    value: enqueueComponent
+                }
+            });
+        }
+        __CreateList(parentComponentUniqueId, componentAtIndex, enqueueComponent) {
+            const e = this.__CreateElement('list', parentComponentUniqueId);
+            Object.defineProperties(e, {
+                componentAtIndex: {
+                    enumerable: false,
+                    configurable: true,
+                    value: componentAtIndex
+                },
+                enqueueComponent: {
+                    enumerable: false,
+                    configurable: true,
+                    value: enqueueComponent
+                }
+            });
+            return e;
+        }
+        __GetTag(ele) {
+            return ele.nodeName;
+        }
+        __GetAttributeByName(ele, name) {
+            return ele.getAttribute(name);
+        }
+        clear() {
+            this.root = void 0;
+        }
+        toTree() {
+            return this.root;
+        }
+        enterListItemAtIndex(e, index, ...args) {
+            const { componentAtIndex, $$uiSign } = e;
+            return componentAtIndex(e, $$uiSign, index, ...args);
+        }
+        leaveListItem(e, uiSign) {
+            const { enqueueComponent, $$uiSign } = e;
+            enqueueComponent(e, $$uiSign, uiSign);
+        }
+        toJSON() {
+            return this.toTree();
+        }
+        __GetElementByUniqueId(uniqueId) {
+            return uniqueId2Element.get(uniqueId);
+        }
+        constructor(){
+            _define_property(this, "root", void 0);
+        }
+    }();
+};
+exports.initElementTree = __webpack_exports__.initElementTree;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "initElementTree"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lynx/ElementPAPI.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Any Lynx Element, such as `view`, `text`, `image`, etc.
+ *
+ * {@link https://lynxjs.org/living-spec/index.html?ts=1743416098203#element%E2%91%A0 | Lynx Spec Reference}
+ *
+ * @public
+ */
+export interface LynxElement extends HTMLElement {
+    /**
+     * The map of events bound to the element.
+     */
+    eventMap?: {
+        [key: string]: any;
+    };
+    /**
+     * The gestures bound to the element.
+     */
+    gesture?: {
+        [key: string]: any;
+    };
+    /**
+     * The cssId of the element
+     */
+    cssId?: string;
+    /**
+     * Returns the first child.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Node/firstChild | MDN Reference}
+     */
+    firstChild: LynxElement;
+    /**
+     * Returns the next sibling.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Node/nextSibling | MDN Reference}
+     */
+    nextSibling: LynxElement;
+    /**
+     * Returns the parent.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Node/parentNode | MDN Reference}
+     */
+    parentNode: LynxElement;
+}
+/**
+ * @public
+ */
+export declare const initElementTree: () => {
+    root: LynxElement | undefined;
+    countElement(element: LynxElement, parentComponentUniqueId: number): void;
+    __CreatePage(_tag: string, parentComponentUniqueId: number): LynxElement;
+    __CreateRawText(text: string): LynxElement;
+    __GetElementUniqueID(e: LynxElement): number;
+    __SetClasses(e: LynxElement, cls: string): void;
+    __CreateElement(tag: string, parentComponentUniqueId: number): LynxElement;
+    __CreateView(parentComponentUniqueId: number): LynxElement;
+    __CreateScrollView(parentComponentUniqueId: number): LynxElement;
+    __FirstElement(e: LynxElement): LynxElement;
+    __CreateText(parentComponentUniqueId: number): LynxElement;
+    __CreateImage(parentComponentUniqueId: number): LynxElement;
+    __CreateWrapperElement(parentComponentUniqueId: number): LynxElement;
+    __AddInlineStyle(e: HTMLElement, key: number, value: string): void;
+    __AppendElement(parent: LynxElement, child: LynxElement): void;
+    __SetCSSId(e: LynxElement | LynxElement[], id: string, entryName?: string): void;
+    __SetAttribute(e: LynxElement, key: string, value: any): void;
+    __AddEvent(e: LynxElement, eventType: string, eventName: string, eventHandler: string | Record<string, any>): void;
+    __GetEvent(e: LynxElement, eventType: string, eventName: string): {
+        type: string;
+        name: string;
+        jsFunction: any;
+    } | undefined;
+    __SetID(e: LynxElement, id: string): void;
+    __SetInlineStyles(e: LynxElement, styles: string | Record<string, string>): void;
+    __AddDataset(e: LynxElement, key: string, value: string): void;
+    __SetDataset(e: LynxElement, dataset: any): void;
+    __SetGestureDetector(e: LynxElement, id: number, type: number, config: any, relationMap: Record<string, number[]>): void;
+    __GetDataset(e: LynxElement): DOMStringMap;
+    __RemoveElement(parent: LynxElement, child: LynxElement): void;
+    __InsertElementBefore(parent: LynxElement, child: LynxElement, ref?: LynxElement): void;
+    __ReplaceElement(newElement: LynxElement, oldElement: LynxElement): void;
+    __FlushElementTree(): void;
+    __UpdateListComponents(_list: LynxElement, _components: string[]): void;
+    __UpdateListCallbacks(list: LynxElement, componentAtIndex: (list: LynxElement, listID: number, cellIndex: number, operationID: number, enable_reuse_notification: boolean) => void, enqueueComponent: (list: LynxElement, listID: number, sign: number) => void): void;
+    __CreateList(parentComponentUniqueId: number, componentAtIndex: any, enqueueComponent: any): LynxElement;
+    __GetTag(ele: LynxElement): string;
+    __GetAttributeByName(ele: LynxElement, name: string): string | null;
+    clear(): void;
+    toTree(): LynxElement | undefined;
+    /**
+     * Enter a list-item element at the given index.
+     * It will load the list-item element using the `componentAtIndex` callback.
+     *
+     * @param e - The list element
+     * @param index - The index of the list-item element
+     * @param args - The arguments used to create the list-item element
+     * @returns The unique id of the list-item element
+     */
+    enterListItemAtIndex(e: LynxElement, index: number, ...args: any[]): number;
+    /**
+     * Leave a list-item element.
+     * It will mark the list-item element as unused using
+     * the `enqueueComponent` callback, and the list-item element
+     * will be reused in the future by other list-item elements.
+     *
+     * @param e - The list element
+     * @param uiSign - The unique id of the list-item element
+     */
+    leaveListItem(e: LynxElement, uiSign: number): void;
+    toJSON(): LynxElement | undefined;
+    __GetElementByUniqueId(uniqueId: number): LynxElement | undefined;
+};