@lynx-js/testing-environment 0.1.0

package/dist/index.cjs

@@ -0,0 +1,329 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    LynxTestingEnv: ()=>LynxTestingEnv,
+    initElementTree: ()=>ElementPAPI_cjs_namespaceObject.initElementTree
+});
+const external_events_namespaceObject = require("events");
+var external_events_default = /*#__PURE__*/ __webpack_require__.n(external_events_namespaceObject);
+const GlobalThis_cjs_namespaceObject = require("./lynx/GlobalThis.cjs");
+const ElementPAPI_cjs_namespaceObject = require("./lynx/ElementPAPI.cjs");
+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, ElementPAPI_cjs_namespaceObject.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 (external_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 (external_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, GlobalThis_cjs_namespaceObject.createGlobalThis)();
+        this.mainThread = (0, GlobalThis_cjs_namespaceObject.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();
+    }
+}
+exports.LynxTestingEnv = __webpack_exports__.LynxTestingEnv;
+exports.initElementTree = __webpack_exports__.initElementTree;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "LynxTestingEnv",
+    "initElementTree"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @packageDocumentation
+ *
+ * A pure-JavaScript implementation of the {@link https://lynxjs.org/guide/spec.html | Lynx Spec},
+ * notably the {@link https://lynxjs.org/api/engine/element-api | Element PAPI} and {@link https://lynxjs.org/guide/spec#dual-threaded-model | Dual-threaded Model} for use with Node.js.
+ */
+import { JSDOM } from 'jsdom';
+import { LynxGlobalThis } from './lynx/GlobalThis.js';
+import { initElementTree } from './lynx/ElementPAPI.js';
+export { initElementTree } from './lynx/ElementPAPI.js';
+export type { LynxElement } from './lynx/ElementPAPI.js';
+export type { LynxGlobalThis } from './lynx/GlobalThis.js';
+/**
+ * @public
+ * The lynx element tree
+ */
+export type ElementTree = ReturnType<typeof initElementTree>;
+/**
+ * @public
+ */
+export type FilterUnderscoreKeys<T> = {
+    [K in keyof T]: K extends `__${string}` ? K : never;
+}[keyof T];
+/**
+ * @public
+ */
+export type PickUnderscoreKeys<T> = Pick<T, FilterUnderscoreKeys<T>>;
+/**
+ * The Element PAPI Types
+ * @public
+ */
+export type ElementTreeGlobals = PickUnderscoreKeys<ElementTree>;
+declare global {
+    var lynxTestingEnv: LynxTestingEnv;
+    var elementTree: ElementTree;
+    var __JS__: boolean;
+    var __LEPUS__: boolean;
+    var __BACKGROUND__: boolean;
+    var __MAIN_THREAD__: boolean;
+    namespace lynxCoreInject {
+        var tt: any;
+    }
+    function onInjectBackgroundThreadGlobals(globals: any): void;
+    function onInjectMainThreadGlobals(globals: any): void;
+    function onSwitchedToBackgroundThread(): void;
+    function onSwitchedToMainThread(): void;
+    function onResetLynxTestingEnv(): void;
+    function onInitWorkletRuntime(): void;
+}
+/**
+ * A pure-JavaScript implementation of the {@link https://lynxjs.org/guide/spec.html | Lynx Spec},
+ * notably the {@link https://lynxjs.org/api/engine/element-api | Element PAPI} and {@link https://lynxjs.org/guide/spec#dual-threaded-model | Dual-threaded Model} for use with Node.js.
+ *
+ * @example
+ *
+ * ```ts
+ * import { LynxTestingEnv } from '@lynx-js/testing-environment';
+ *
+ * const lynxTestingEnv = new LynxTestingEnv();
+ *
+ * lynxTestingEnv.switchToMainThread();
+ * // use the main thread Element PAPI
+ * const page = __CreatePage('0', 0);
+ * const view = __CreateView(0);
+ * __AppendElement(page, view);
+ *
+ * ```
+ *
+ * @public
+ */
+export declare class LynxTestingEnv {
+    private originals;
+    /**
+     * The global object for the background thread.
+     *
+     * @example
+     *
+     * ```ts
+     * import { LynxTestingEnv } from '@lynx-js/testing-environment';
+     *
+     * const lynxTestingEnv = new LynxTestingEnv();
+     *
+     * lynxTestingEnv.switchToBackgroundThread();
+     * // use the background thread global object
+     * globalThis.lynxCoreInject.tt.OnLifecycleEvent(...args);
+     * ```
+     */
+    backgroundThread: LynxGlobalThis;
+    /**
+     * The global object for the main thread.
+     *
+     * @example
+     *
+     * ```ts
+     * import { LynxTestingEnv } from '@lynx-js/testing-environment';
+     *
+     * const lynxTestingEnv = new LynxTestingEnv();
+     *
+     * lynxTestingEnv.switchToMainThread();
+     * // use the main thread global object
+     * const page = globalThis.__CreatePage('0', 0);
+     * const view = globalThis.__CreateView(0);
+     * globalThis.__AppendElement(page, view);
+     * ```
+     */
+    mainThread: LynxGlobalThis & ElementTreeGlobals;
+    jsdom: JSDOM;
+    constructor();
+    injectGlobals(): void;
+    switchToBackgroundThread(): void;
+    switchToMainThread(): void;
+    clearGlobal(): void;
+    reset(): void;
+}