@sigx/lynx-runtime-main 0.4.0 → 0.4.1

package/dist/upstream/processGesture.js

@@ -0,0 +1,147 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// TypeScript types added 2026 by SignalX contributors.
+//
+// Licensed under the Apache License, Version 2.0. The full license text and
+// upstream attribution are reproduced in `THIRD_PARTY_NOTICES.md` at the
+// root of this package (`@sigx/lynx-runtime-main`). The MIT LICENSE at the
+// repository root governs the rest of this repository; it does NOT apply
+// to this file.
+//
+// TS port of `@lynx-js/react@0.119.0`'s
+// `runtime/lib/gesture/processGesture.js`. Source preserved verbatim; only
+// types added. Why vendor: upstream's `gesture/processGesture.js` is the
+// canonical platform-call sequence used by `@lynx-js/react`'s snapshot
+// pipeline. Calling our hand-rolled equivalent on a real device shows the
+// gesture arena doesn't engage; vendoring eliminates any subtle divergence.
+//
+// Sigx-specific deltas:
+//   - `dom` is sigx's raw `MainThreadElement`, not a SnapshotInstance member.
+//   - Caller passes `isFirstScreen=false` (no SSR/hydration in sigx).
+//   - `gestureOptions` always undefined.
+import { onWorkletCtxUpdate } from './observers.js';
+const COMPOSED = -1;
+function isSerializedGesture(gesture) {
+    return gesture?.__isSerialized === true;
+}
+function getSerializedBaseGesture(gesture) {
+    if (!gesture || !isSerializedGesture(gesture))
+        return undefined;
+    if (gesture.type !== COMPOSED)
+        return gesture;
+    return undefined;
+}
+function appendUniqueSerializedBaseGestures(gesture, out, seenIds) {
+    if (!gesture || !isSerializedGesture(gesture))
+        return;
+    if (gesture.type === COMPOSED) {
+        for (const sub of gesture.gestures) {
+            appendUniqueSerializedBaseGestures(sub, out, seenIds);
+        }
+        return;
+    }
+    const base = gesture;
+    if (seenIds.has(base.id))
+        return;
+    seenIds.add(base.id);
+    out.push(base);
+}
+function appendOldGestureInfo(gesture, out, byId) {
+    if (!gesture || !isSerializedGesture(gesture))
+        return;
+    if (gesture.type === COMPOSED) {
+        for (const sub of gesture.gestures) {
+            appendOldGestureInfo(sub, out, byId);
+        }
+        return;
+    }
+    const base = gesture;
+    if (!byId.has(base.id)) {
+        byId.set(base.id, base);
+        out.push(base);
+    }
+}
+function collectOldGestureInfo(oldGesture) {
+    const uniqOldBaseGestures = [];
+    const oldBaseGesturesById = new Map();
+    appendOldGestureInfo(oldGesture, uniqOldBaseGestures, oldBaseGesturesById);
+    return { uniqOldBaseGestures, oldBaseGesturesById };
+}
+function consumeOldBaseGesture(baseGesture, uniqOldBaseGestures, oldBaseGesturesById) {
+    const idMatched = oldBaseGesturesById.get(baseGesture.id);
+    if (idMatched) {
+        oldBaseGesturesById.delete(baseGesture.id);
+        return idMatched;
+    }
+    const fallback = uniqOldBaseGestures.find((og) => oldBaseGesturesById.has(og.id));
+    if (!fallback)
+        return undefined;
+    oldBaseGesturesById.delete(fallback.id);
+    return fallback;
+}
+function removeGestureDetector(dom, id) {
+    if (typeof __RemoveGestureDetector === 'function') {
+        __RemoveGestureDetector(dom, id);
+    }
+}
+function getGestureInfo(gesture, oldGesture, isFirstScreen, dom) {
+    const config = { callbacks: [] };
+    if (gesture.config) {
+        config.config = gesture.config;
+    }
+    for (const key of Object.keys(gesture.callbacks)) {
+        const callback = gesture.callbacks[key];
+        const oldCallback = oldGesture?.callbacks[key];
+        // Upstream types `Worklet._c` as `Record<string, ClosureValueType>`; ours
+        // is `Record<string, unknown>` from the wire. The runtime contract is
+        // identical — cast through `unknown` to satisfy the upstream signature.
+        onWorkletCtxUpdate(callback, oldCallback, isFirstScreen, dom);
+        config.callbacks.push({ name: key, callback });
+    }
+    const relationMap = {
+        waitFor: gesture.waitFor?.map((g) => g.id) ?? [],
+        simultaneous: gesture.simultaneousWith?.map((g) => g.id) ?? [],
+        continueWith: gesture.continueWith?.map((g) => g.id) ?? [],
+    };
+    return { config, relationMap };
+}
+export function processGesture(dom, gesture, oldGesture, isFirstScreen, gestureOptions) {
+    const domSet = gestureOptions?.domSet === true;
+    const { uniqOldBaseGestures, oldBaseGesturesById } = collectOldGestureInfo(oldGesture);
+    const singleBaseGesture = getSerializedBaseGesture(gesture);
+    const singleOldBaseGesture = getSerializedBaseGesture(oldGesture);
+    if (singleBaseGesture && (!oldGesture || singleOldBaseGesture)) {
+        if (!domSet) {
+            __SetAttribute(dom, 'has-react-gesture', true);
+            __SetAttribute(dom, 'flatten', false);
+        }
+        if (singleOldBaseGesture) {
+            removeGestureDetector(dom, singleOldBaseGesture.id);
+        }
+        const { config, relationMap } = getGestureInfo(singleBaseGesture, singleOldBaseGesture, isFirstScreen, dom);
+        __SetGestureDetector(dom, singleBaseGesture.id, singleBaseGesture.type, config, relationMap);
+        return;
+    }
+    const uniqBaseGestures = [];
+    appendUniqueSerializedBaseGestures(gesture, uniqBaseGestures, new Set());
+    if (uniqBaseGestures.length === 0) {
+        for (const og of oldBaseGesturesById.values()) {
+            removeGestureDetector(dom, og.id);
+        }
+        if (!domSet) {
+            __SetAttribute(dom, 'has-react-gesture', null);
+        }
+        return;
+    }
+    if (!domSet) {
+        __SetAttribute(dom, 'has-react-gesture', true);
+        __SetAttribute(dom, 'flatten', false);
+    }
+    for (const og of oldBaseGesturesById.values()) {
+        removeGestureDetector(dom, og.id);
+    }
+    for (const base of uniqBaseGestures) {
+        const oldBase = consumeOldBaseGesture(base, uniqOldBaseGestures, oldBaseGesturesById);
+        const { config, relationMap } = getGestureInfo(base, oldBase, isFirstScreen, dom);
+        __SetGestureDetector(dom, base.id, base.type, config, relationMap);
+    }
+}

package/dist/worklet-events.js

@@ -0,0 +1,47 @@
+/**
+ * Helpers for invoking worklets from the BG → MT bridge.
+ *
+ * Most of the worklet machinery (registry, ref map, event dispatch) is owned
+ * by `@lynx-js/react/worklet-runtime`, which is side-effect-imported from
+ * `entry-main.ts`. That runtime installs `globalThis.lynxWorkletImpl`,
+ * `globalThis.registerWorkletInternal`, and `globalThis.runWorklet`. Lynx
+ * native dispatches MT-routed events directly into `runWorklet`.
+ *
+ * What sigx-lynx still needs to provide is the `runOnMainThread` BG → MT call
+ * path: BG ships `{ wkltId, args }` over `callLepusMethod('sigxRunOnMT')`, the
+ * MT bridge handler in `entry-main.ts` calls `invokeWorklet()` here, and we
+ * look up the function in upstream's `_workletMap`.
+ */
+function getWorkletImpl() {
+    return globalThis['lynxWorkletImpl'];
+}
+/**
+ * Invoke a worklet by id with the given args. Used by the runOnMainThread
+ * bridge — event-driven worklets go through Lynx's native runWorklet path
+ * and never touch this function.
+ */
+export function invokeWorklet(wkltId, captured, args) {
+    const impl = getWorkletImpl();
+    if (!impl) {
+        console.log('[sigx-mt] lynxWorkletImpl not initialized');
+        return undefined;
+    }
+    const fn = impl._workletMap[wkltId];
+    if (!fn) {
+        console.log('[sigx-mt] worklet not registered:', wkltId);
+        return undefined;
+    }
+    // Match upstream's calling convention: `function(arg) { let { x } = this["_c"]; ... }`
+    try {
+        return fn.apply({ _c: captured ?? {} }, args);
+    }
+    catch (e) {
+        console.log('[sigx-mt] worklet threw:', String(e));
+        return undefined;
+    }
+}
+/** Reset hook — for testing. The upstream worklet-runtime has its own state. */
+export function resetWorkletEvents() {
+    // No sigx-side state to clear; upstream's _workletMap survives module reset
+    // (registrations re-run when the user module re-evaluates on hot reload).
+}

package/dist/worklet-refs.js

@@ -0,0 +1,43 @@
+/**
+ * Worklet ref registry — manages MainThreadRef state on the Main Thread.
+ *
+ * Each ref is identified by a worklet variable ID (wvid) assigned on the
+ * BG thread. When INIT_MT_REF arrives, we create a holder. When SET_MT_REF
+ * arrives, we set the holder's .current to the real element wrapper.
+ */
+import { MTElementWrapper } from './mt-element.js';
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+const workletRefs = new Map();
+/**
+ * Initialize a worklet ref on the Main Thread.
+ * Called when the BG thread sends INIT_MT_REF(wvid, initValue).
+ */
+export function initWorkletRef(wvid, initValue) {
+    workletRefs.set(wvid, { current: initValue });
+}
+/**
+ * Bind a worklet ref to a Main Thread element.
+ * Called when the BG thread sends SET_MT_REF(elementId, wvid).
+ * The ref's .current is set to an MTElementWrapper around the real element.
+ */
+export function bindWorkletRef(wvid, el) {
+    const holder = workletRefs.get(wvid);
+    if (holder) {
+        holder.current = new MTElementWrapper(el);
+    }
+}
+/**
+ * Get a worklet ref holder by wvid — used by worklet event handlers
+ * to access refs.
+ */
+export function getWorkletRef(wvid) {
+    return workletRefs.get(wvid);
+}
+/**
+ * Reset all worklet refs — for testing and hot reload.
+ */
+export function resetWorkletRefs() {
+    workletRefs.clear();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigx/lynx-runtime-main",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Main Thread (Lepus) entry and ops applier for SignalX Lynx renderer",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,7 +42,7 @@
     "url": "https://github.com/signalxjs/lynx/issues"
   },
   "dependencies": {
-    "@sigx/lynx-runtime-internal": "0.4.0"
+    "@sigx/lynx-runtime-internal": "0.4.1"
   },
   "peerDependencies": {
     "@lynx-js/types": ">=3.0.0"
@@ -53,16 +53,16 @@
     }
   },
   "devDependencies": {
-    "@lynx-js/types": "^3.7.0",
-    "@sigx/vite": "^0.4.3",
-    "typescript": "^6.0.3",
-    "vite": "^8.0.12"
+    "@lynx-js/types": "^3.9.0",
+    "@typescript/native-preview": "7.0.0-dev.20260511.1",
+    "typescript": "^6.0.3"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "vite build && tsgo --emitDeclarationOnly",
-    "dev": "vite build --watch"
+    "build": "node ../../scripts/clean.mjs dist && tsgo",
+    "dev": "tsgo --watch",
+    "clean": "node ../../scripts/clean.mjs dist .turbo"
   }
 }