@lynx-js/testing-environment 0.1.0

package/dist/lynx/ElementPAPI.js

@@ -0,0 +1,230 @@
+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);
+        }
+    }();
+};
+export { initElementTree };

package/dist/lynx/GlobalThis.cjs

@@ -0,0 +1,49 @@
+"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__, {
+    createGlobalThis: ()=>createGlobalThis
+});
+const external_util_cjs_namespaceObject = require("../util.cjs");
+function installOwnProperties(globalThis) {
+    (0, external_util_cjs_namespaceObject.define)(globalThis, {
+        get globalThis () {
+            return globalThis._globalProxy;
+        }
+    });
+}
+const createGlobalThis = ()=>{
+    const globalThis = {};
+    globalThis._globalObject = globalThis._globalProxy = globalThis;
+    installOwnProperties(globalThis);
+    return globalThis;
+};
+exports.createGlobalThis = __webpack_exports__.createGlobalThis;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createGlobalThis"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lynx/GlobalThis.d.ts

@@ -0,0 +1,13 @@
+export declare const createGlobalThis: () => LynxGlobalThis;
+/**
+ * The `globalThis` object of Lynx dual thread environment.
+ *
+ * @public
+ */
+export interface LynxGlobalThis {
+    /**
+     * The globalThis object.
+     */
+    globalThis: LynxGlobalThis;
+    [key: string]: any;
+}

package/dist/lynx/GlobalThis.js

@@ -0,0 +1,15 @@
+import * as __WEBPACK_EXTERNAL_MODULE__util_js_1dab4bad__ from "../util.js";
+function installOwnProperties(globalThis) {
+    (0, __WEBPACK_EXTERNAL_MODULE__util_js_1dab4bad__.define)(globalThis, {
+        get globalThis () {
+            return globalThis._globalProxy;
+        }
+    });
+}
+const createGlobalThis = ()=>{
+    const globalThis = {};
+    globalThis._globalObject = globalThis._globalProxy = globalThis;
+    installOwnProperties(globalThis);
+    return globalThis;
+};
+export { createGlobalThis };

package/dist/util.cjs

@@ -0,0 +1,41 @@
+"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__, {
+    define: ()=>define
+});
+function define(object, properties) {
+    for (const name of Object.getOwnPropertyNames(properties)){
+        const propDesc = Object.getOwnPropertyDescriptor(properties, name);
+        Object.defineProperty(object, name, propDesc);
+    }
+}
+exports.define = __webpack_exports__.define;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "define"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/util.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Define a set of properties on an object, by copying the property descriptors
+ * from the original object.
+ *
+ * - `object` {Object} the target object
+ * - `properties` {Object} the source from which to copy property descriptors
+ */
+export declare function define(object: any, properties: any): void;

package/dist/util.js

@@ -0,0 +1,7 @@
+function util_define(object, properties) {
+    for (const name of Object.getOwnPropertyNames(properties)){
+        const propDesc = Object.getOwnPropertyDescriptor(properties, name);
+        Object.defineProperty(object, name, propDesc);
+    }
+}
+export { util_define as define };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@lynx-js/testing-environment",
+  "version": "0.1.0",
+  "description": "A subset of a Lynx environment to be useful for testing",
+  "keywords": [
+    "Lynx",
+    "ReactLynx",
+    "testing"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lynx-family/lynx-stack.git",
+    "directory": "packages/testing-library/test-environment"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Yiming Li",
+    "email": "yimingli.cs@gmail.com"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./env/vitest": {
+      "types": "./dist/env/vitest/index.d.ts",
+      "import": "./dist/env/vitest/index.js",
+      "require": "./dist/env/vitest/index.cjs",
+      "default": "./dist/env/vitest/index.js"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "env/vitest": [
+        "./dist/env/vitest/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.6.3",
+    "@types/jsdom": "^21.1.7",
+    "rsbuild-plugin-publint": "0.3.1"
+  },
+  "scripts": {
+    "api-extractor": "api-extractor run --verbose",
+    "build": "rslib build",
+    "dev": "rslib build --watch"
+  }
+}