mithril-lynx 0.0.8 → 2.0.0

package/CONTRACT.md

@@ -1,151 +0,0 @@
-# Mithril 2.3.8 `render/render.js` — Extracted Contract
-
-Source: `node_modules/mithril/render/render.js` (910 lines), mithril **2.3.8**.
-All line numbers cite that file unless prefixed with `hyperscript.js:` (which cites `node_modules/mithril/render/hyperscript.js`).
-
----
-
-## a. Factory signature & how the render function is obtained
-
-- **Line 8**: `module.exports = function() {` — the module exports a **zero-argument factory function**.
-- The factory closes over module-level mutable state:
-  - `currentRedraw` (line 14) — the active `redraw` callback, captured by `EventDict` for auto-redraw.
-  - `currentRender` (line 15) — a per-render generation marker object (used by `delayedRemoval`).
-  - `currentDOM` (line 880) — the DOM node currently being rendered to (reentrancy lock).
-- The **render function is the closure returned by the factory**: lines 882–909, `return function(dom, vnodes, redraw) { ... }`.
-- Module dependencies (lines 3–6): `./vnode`, `./delayedRemoval`, `./domFor`, `./cachedAttrsIsStaticMap`.
-- The factory pattern means each call to `require("mithril/render/render")()` produces an **independent renderer instance** with its own `currentRedraw`/`currentDOM`/`currentRender` state.
-
-## b. Render function signature: `render(dom, vnodes, redraw)`
-
-Defined at **line 882**: `return function(dom, vnodes, redraw) {`
-
-| Param | Contract |
-|---|---|
-| `dom` | The DOM element to render into. **Line 883**: throws `TypeError("DOM element being rendered to does not exist.")` if falsy. **Lines 884–886**: throws `TypeError("Node is currently being rendered to and thus is locked.")` if `currentDOM != null && dom.contains(currentDOM)` (reentrancy guard). |
-| `vnodes` | A vnode or array of vnodes. **Line 899**: normalized via `Vnode.normalizeChildren(Array.isArray(vnodes) ? vnodes : [vnodes])`. |
-| `redraw` | Optional. **Line 894**: `currentRedraw = typeof redraw === "function" ? redraw : undefined`. Consumed by `EventDict.handleEvent` (lines 811–817) to auto-redraw after events. |
-
-Body sequence:
-1. **Line 898**: first render into a node clears it — `if (dom.vnodes == null) dom.textContent = ""`.
-2. **Line 900**: `updateNodes(dom, dom.vnodes, vnodes, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace)` — diffs old (`dom.vnodes`) vs new (`vnodes`); the XHTML namespace is normalized to `undefined` (which enables the property-key path in `hasPropertyKey`).
-3. **Line 901**: `dom.vnodes = vnodes` — **prior vnodes are stored on the DOM node itself**.
-4. **Line 903**: focus restoration — if `document.activeElement` changed and the old active element still has `.focus`, it is refocused.
-5. **Line 904**: post-render hooks (`oncreate`/`onupdate`) flushed in order.
-6. **Lines 905–908**: `finally` restores `currentRedraw`/`currentDOM` to their previous values.
-
-## c. DOM surface accessed on the `dom` parameter
-
-All access goes through the `dom` node passed to `render()` (or its descendants). `getDocument(dom)` (lines 17–19) returns `dom.ownerDocument`.
-
-| API | Lines | Usage |
-|---|---|---|
-| `ownerDocument` | 18 | `getDocument()`; source of all document-level factories |
-| `createTextNode` | 76 | `createText` — `vnode.dom = getDocument(parent).createTextNode(vnode.children)` |
-| `createElement` / `createElementNS` | 120–122 | `createElement` for HTML, `createElementNS(ns, tag)` for svg/math; `{is: is}` third arg for custom elements |
-| `createDocumentFragment` | 96, 104, 551 | `createHTML` (96), `createFragment` (104), `moveDOM` for multi-node moves (551) |
-| `insertBefore` / `appendChild` | 558–561 | `insertDOM`: `insertBefore(dom, nextSibling)` if `nextSibling != null`, else `appendChild(dom)` |
-| `removeChild` | 610–617 | `removeDOM`: single `removeChild(vnode.dom)` or per-node via `domFor` for fragments |
-| `nodeValue` | 422 | `updateText` — `old.dom.nodeValue = vnode.children` |
-| `value` | 654–658, 666, 699, 703 | Read for same-value coercion skips (input/textarea/select/option); written via generic `vnode.dom[key] = value` (666); select late-attrs (699, 703) |
-| `checked` | 730 | Only as a key name in `isFormAttribute`; written via generic property path (666) |
-| `selectedIndex` | 685, 699, 702, 707 | `removeAttr` guard (685), `setLateSelectAttrs` (699, 702, 707) |
-| `className` | 672, 681, 693 | `setAttr` maps `className` → `"class"` attribute (672); `removeAttr` excludes it from property-null path (681) and maps to `"class"` (693) |
-| `setAttribute` | 665, 669–670, 672 | input `type` (665), boolean attrs (669–670), generic attrs (672) |
-| `removeAttribute` | 670, 693 | boolean-false (670), generic removal (693) |
-| `setAttributeNS` | 645 | `xlink:`-prefixed keys → `setAttributeNS("http://www.w3.org/1999/xlink", key.slice(6), value)` |
-| `style` | 646, 678, 747–787 | `updateStyle` dual-mode (see §f) |
-| `innerHTML` | 89, 92, 571 | `createHTML` (89 svg-wrapped, 92 plain), contenteditable sync (571) |
-| `textContent` | 898 | First-render clear |
-| `firstChild` | 90, 94, 98, 109 | `createHTML` unwrap (90, 94, 98), `createFragment` dom anchor (109) |
-| `parentNode` | 730 | `isFormAttribute` — `option` whose parent is the active element |
-| `contains` | 884 | Reentrancy lock check |
-| `namespaceURI` | 891 | Namespace detection for the diff call |
-| `focus` | 903 | Focus restoration |
-| `nextSibling` | domFor.js:12 | Fragment iteration in `domFor` |
-
-**Not used (verified by grep across the whole package):**
-- `getAttribute` — render.js only *writes* attributes (`setAttribute`/`removeAttribute`/`setAttributeNS`); it never reads them.
-- `nodeType` — appears nowhere in mithril. Do not rely on it in a reimplementation.
-
-## d. Prior-vnode storage & diffing of repeated `render()` calls
-
-**Storage**: old vnodes live on the DOM node as `dom.vnodes` — read at line 898 (first-render check) and 900 (diff input), written at line 901.
-
-**`updateNodes(parent, old, vnodes, hooks, nextSibling, ns)`** (lines 270–395):
-
-1. **Trivial cases** (271–273): `old === vnodes` or both null → no-op; `old` empty → create all; `vnodes` empty → remove all.
-2. **Keyed detection** (275–276): lists are keyed iff `old[0].key != null` / `vnodes[0].key != null` (first non-null node, 278–279).
-3. **Keyed/unkeyed mismatch** (280–282): remove all old + create all new.
-4. **Unkeyed diff** (283–299): walk the common length index-by-index; `o === v` or both null → skip; null old → create; null new → remove; else `updateNode`. Tails handled by `removeNodes` (298) / `createNodes` (299).
-5. **Keyed diff** (300–392), with the documented optimizations (comment block 184–268):
-   - **Bottom-up tail match** (305–312): while tail keys equal, update in place — identical tails are guaranteed part of the LIS, so no moves (tail optimization, comment 244–245).
-   - **Top-down head match** (314–320): same for the head.
-   - **Swaps & reversals** (322–336): two-node cross-swap fast path.
-   - **Bottom-up again** (338–345): re-check tails after head/tail consumption.
-   - **Leftovers** (346–347): remove remaining old or create remaining new.
-   - **LIS-based middle diff** (348–391): builds `oldIndices` (350–351), maps new keys → old indices via `getKeyMap` (352–365; impl 478–488), nulls matched old entries, removes unmatched old (367), creates all if nothing matched (368), then either moves non-LIS nodes (`makeLisIndices`, 370–383; impl 494–534, lifted from ivi) or a simple create loop when order was preserved (384–390).
-6. **`getNextSibling`** (536–541): next sibling is found by scanning the *old* list forward from `i+1` for a node with a `dom` — this is what makes top-down DOM insertion correct.
-7. **`moveDOM`** (544–556): moves single nodes directly; multi-node fragments are moved via a `createDocumentFragment` + `domFor` loop.
-
-**`updateNode`** (396–419): same `tag` + same `is` → in-place update (state/events carried over at 399–400; `shouldNotUpdate` short-circuit at 401, impl 852–878); otherwise `removeNode` + `createNode`. Per-tag updates: `updateText` (420–425), `updateHTML` (426–435), `updateFragment` (436–450), `updateElement` (451–461), `updateComponent` (462–477).
-
-## e. How `m()` (hyperscript) creates events & attrs
-
-**Hyperscript side** (`render/hyperscript.js`):
-- Selector parsing: `compileSelector` (hyperscript.js:21–42) — `#id`, `.class`, `[attr]`, `[attr=value]`; `class` → `className` (hyperscript.js:38); form-attribute keys (`value`/`checked`/`selectedIndex`/`selected`) mark the attrs object as non-static (hyperscript.js:17–19, 34).
-- `class` attr → `className` (hyperscript.js:54–57); `input[type]` reordered first (hyperscript.js:69–74, workaround for #2622); `vnode.is = attrs.is` (hyperscript.js:77).
-
-**Event side** (render.js):
-- **Dispatch rule** (line 644): any attr key starting with `on` (`key[0] === "o" && key[1] === "n"`) is routed to `updateEvent` (826–842), never to the DOM attribute path.
-- **`EventDict`** (800–823): a per-element event listener object, prototype `Object.create(null)` (804). Constructor captures `this._ = currentRedraw` (802). `handleEvent(ev)` (805–823):
-  - Looks up `this["on" + ev.type]` (806).
-  - Function handler → called with `ev.currentTarget` as `this` (808); object handler → `handler.handleEvent(ev)` (809).
-  - Auto-redraw: if `this._ != null` and `ev.redraw !== false`, calls the captured redraw (811–812); also after the handler's returned promise resolves (813–817).
-  - `return false` → `ev.preventDefault()` + `ev.stopPropagation()` (819–822).
-- **`updateEvent`** (826–842): `addEventListener(key.slice(2), vnode.events, false)` — the **EventDict object itself is the listener** (831, 839); handlers stored as `vnode.events[key]`; removal via `removeEventListener` (834). `vnode.events` is carried across updates (line 400).
-
-**Attribute side** (render.js):
-- **`setAttr`** (642–674) precedence: skip `key`/null-value/lifecycle (643) → `on*` events (644) → `xlink:` (645) → `style` (646) → **`hasPropertyKey`** (647–666) → attribute fallback (667–673).
-- **`hasPropertyKey`** (735–744): property assignment only when `ns === undefined` AND (custom element: tag contains `-` or `vnode.is`, OR key not in the browser-bug blacklist `href`/`list`/`form`/`width`/`height`) AND `key in vnode.dom`.
-- Property path (666): `vnode.dom[key] = value`, with `value` coercion guards (648–663: input/textarea/select/option same-value skip; file-input read-only warning at 661) and `input[type]` forced through `setAttribute` (665).
-- Attribute path (667–673): boolean → `setAttribute(key, "")` / `removeAttribute(key)`; else `setAttribute(key === "className" ? "class" : key, value)`.
-- **`removeAttr`** (675–695): property-null path excludes `className`, `title`, `value` (option/select edge), `input[type]`; else `removeAttribute` with `className` → `"class"` mapping.
-- **`updateAttrs`** (709–728): removals first (713–722), then sets (723–727); warns on reused attrs objects (714–716).
-- **`isFormAttribute`** (729–731): `value`/`checked`/`selectedIndex`/`selected` (with active-element/option-parent conditions) — these bypass the `old === value` skip so form state always syncs.
-
-## f. `updateStyle()` dual-mode (lines 747–787)
-
-`updateStyle(element, old, style)`:
-
-| Case | Lines | Behavior |
-|---|---|---|
-| `old === style` | 748–749 | No-op |
-| `style == null` | 750–752 | `element.style = ""` (clear) |
-| `typeof style !== "object"` | 753–755 | `element.style = style` (string passthrough) |
-| `old` missing/string, `style` object | 756–766 | Clear, then for each key: **`key.includes("-")` → `element.style.setProperty(key, String(value))`** (763); **else `element.style[key] = String(value)`** (764) |
-| Both objects | 767–786 | Remove stale keys first (772–777: `removeProperty` for dash-case, `= ""` for camelCase), then set changed keys (779–785: same dual-mode) |
-
-Key contract points:
-- **Dash-case keys** (`-` in the name) → `setProperty` / `removeProperty`; **camelCase keys** → direct `style[k]` assignment.
-- All values coerced with `String()` (763–764, 781).
-- Removal happens before setting (770–771) to avoid dash-case/camelCase aliasing bugs.
-
-## g. Version & packaging
-
-- **Version**: `2.3.8` (package.json `version` field).
-- **No `main` / `module` field** in package.json (verified — only `unpkg`/`jsdelivr`/`repository`/`license`/`scripts`/`devDependencies`). The package is consumed by **file-path require**: `require("mithril/render/render")` resolves directly to `node_modules/mithril/render/render.js`.
-- Entry points: `index.js` (browser bundle), `render.js` (top-level re-export of `render/render.js`), `hyperscript.js` (re-export of `render/hyperscript.js` + `trust`/`fragment`).
-- 2.3.8 is the latest mithril release on npm (as of this scaffold's dependency pin).
-
----
-
-## Reimplementation checklist (what a Lynx port must honor)
-
-1. Factory `module.exports = function()` returning `function(dom, vnodes, redraw)` with per-instance `currentRedraw`/`currentRender`/`currentDOM` state.
-2. Store prior vnodes on the target node (`dom.vnodes`); first render clears via `textContent = ""`.
-3. Diff pipeline: trivial cases → keyed detection → unkeyed walk → keyed (tail/head/swaps/LIS) → leftover create/remove.
-4. DOM surface: `createTextNode`, `createElement(NS)`, `createDocumentFragment`, `insertBefore`/`appendChild`, `removeChild`, `nodeValue`, `value`, `checked`, `selectedIndex`, `className`, `setAttribute`/`removeAttribute`/`setAttributeNS`, `style`, `innerHTML`, `textContent`, `firstChild`, `parentNode`, `ownerDocument`, `namespaceURI`, `contains`, `focus`. **No `getAttribute`, no `nodeType`.**
-5. Events: `on*` keys → single `EventDict` object per element registered via `addEventListener`; `handleEvent` dispatches by `ev.type`, binds `this` to `ev.currentTarget`, auto-redraws, honors `return false`.
-6. Attrs: `hasPropertyKey` gate (property vs attribute), `className`→`class` mapping, boolean attrs, `xlink:` namespace, `value`/`checked`/`selectedIndex` form-attribute exceptions.
-7. Styles: dual-mode `updateStyle` — `setProperty` for `-` keys, `style[k] = v` for camelCase, `String()` coercion, remove-before-set.

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 carlos-sweb
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/background.d.ts

@@ -1,54 +0,0 @@
-// Ambient declaration for the ESM background.js (the file itself is not
-// type-checked; this describes its runtime export shape for TS consumers).
-
-export type StoreData = Record<string, unknown>;
-
-export interface SetDataOptions {
-  /** Set false to update the store without pushing a sync to the main thread. Defaults to true. */
-  shouldSyncToMainThread?: boolean;
-}
-
-/** Returns the background thread's mutable data store. */
-export function getData<T = StoreData>(): T;
-
-/** Merges `patch` into the store, then (by default) pushes the changed keys to the main thread. */
-export function setData(patch: StoreData, options?: SetDataOptions): void;
-
-/**
- * Registers the single handler invoked for every dispatchToBackground() call
- * made from the main thread, as (handlerName, data).
- */
-export function setBackgroundEventHandler(
-  handleEvent: (handlerName: string, data: unknown) => unknown,
-): void;
-
-/**
- * Wires the background thread's core-context listeners for the
- * main-thread <-> background-thread data channel. Call once, at
- * background.ts's top level. See the project plan, Phase 3.
- */
-export function setupBackground(): void;
-
-export interface BackgroundRef {
-  /** Resolves with the native method's success data, rejects with its failure data. */
-  invoke(method: string, params?: Record<string, unknown>): Promise<unknown>;
-}
-
-/**
- * A background-thread ref: imperative calls to a native element identified
- * by a CSS selector, via lynx.createSelectorQuery(). See the project plan,
- * Phase 5.
- */
-export function createRef(selector: string): BackgroundRef;
-
-/**
- * Registers a handler main-thread.js's runOnBackground(key, ...args) can
- * call by name. See the project plan, Phase 6.
- */
-export function registerHandler(key: string, fn: (...args: unknown[]) => unknown): void;
-
-/**
- * Calls a handler main-thread.js registered via registerHandler(key, fn).
- * Args and the resolved value must be JSON-serializable.
- */
-export function runOnMainThread<T = unknown>(key: string, ...args: unknown[]): Promise<T>;

package/background.js

@@ -1,169 +0,0 @@
-// background.js
-//
-// Cross-thread "data-channel mode" adapter for the background thread (see
-// the project plan, Phase 3). Ports
-// lynx-examples/examples/vanilla/src/common/background/{setup,data,event}.ts
-// into a single module — this side is framework-agnostic (Mithril never
-// renders on the background thread in data-channel mode), so nothing here
-// depends on the shim.
-//
-// A single mutable data store is diffed against its last-synced snapshot on
-// every setData() call and only the changed keys are pushed to the main
-// thread. Data received FROM the main thread is never echoed back (the
-// reference implementation does, on every update after the first — a
-// pure round-trip echo that's wasteful, and directly visible as a redundant
-// extra Mithril redraw in this port, so it isn't reproduced here).
-
-import {
-	callBackgroundEventName,
-	callBackgroundResultEventName,
-	callMainThreadEventName,
-	callMainThreadResultEventName,
-	destroyLifetimeEventName,
-	dispatchEventToBackgroundEventName,
-	updateDataFromBackgroundEventName,
-	updateDataFromMainThreadEventName,
-} from "./internal/constants.js";
-
-const data = {};
-let lastSyncedData = { ...data };
-let handleBackgroundEvent;
-
-export function getData() {
-	return data;
-}
-
-export function setData(patch, options = {}) {
-	const { shouldSyncToMainThread = true } = options;
-	Object.assign(data, patch);
-	if (!shouldSyncToMainThread) {
-		lastSyncedData = { ...data };
-		return;
-	}
-	sendToMainThread();
-}
-
-function sendToMainThread() {
-	const patch = {};
-	for (const [key, value] of Object.entries(data)) {
-		if (value !== lastSyncedData[key]) patch[key] = value;
-	}
-	if (Object.keys(patch).length === 0) return;
-	lastSyncedData = { ...data };
-	lynx.getCoreContext().dispatchEvent({
-		type: updateDataFromBackgroundEventName,
-		data: patch,
-	});
-}
-
-// handleEvent(handlerName, data) — called for every dispatchToBackground()
-// call made from the main thread. Only one handler at a time; Phase 6 of the
-// project plan generalizes this into a full string-keyed registry with
-// call/return correlation.
-export function setBackgroundEventHandler(handleEvent) {
-	handleBackgroundEvent = handleEvent;
-}
-
-export function setupBackground() {
-	const coreContext = lynx.getCoreContext();
-
-	const onUpdateDataFromMainThread = (event) => {
-		const incoming = event.data;
-		if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return;
-		// Never echo data back to the thread it just came from — only
-		// background-initiated setData() calls (elsewhere in app code)
-		// should sync to the main thread.
-		setData(incoming, { shouldSyncToMainThread: false });
-	};
-
-	const onDispatchToBackground = (event) => {
-		const payload = event.data;
-		if (!payload || typeof payload.handlerName !== "string") return;
-		handleBackgroundEvent?.(payload.handlerName, payload.data);
-	};
-
-	const cleanup = () => {
-		coreContext.removeEventListener(updateDataFromMainThreadEventName, onUpdateDataFromMainThread);
-		coreContext.removeEventListener(dispatchEventToBackgroundEventName, onDispatchToBackground);
-		coreContext.removeEventListener(destroyLifetimeEventName, cleanup);
-	};
-
-	coreContext.addEventListener(updateDataFromMainThreadEventName, onUpdateDataFromMainThread);
-	coreContext.addEventListener(dispatchEventToBackgroundEventName, onDispatchToBackground);
-	coreContext.addEventListener(destroyLifetimeEventName, cleanup);
-}
-
-// Refs (project plan, Phase 5): the background thread has no direct native
-// handle, so imperative calls go through Lynx's existing selector-query
-// bridge (the same primitive ReactLynx's own background-thread refs
-// ultimately bottom out on) rather than a new protocol.
-export function createRef(selector) {
-	return {
-		invoke(method, params) {
-			return new Promise((resolve, reject) => {
-				lynx.createSelectorQuery()
-					.select(selector)
-					.invoke({
-						method,
-						params: params || {},
-						success: (data) => resolve(data),
-						fail: (data) => reject(data),
-					})
-					.exec();
-			});
-		},
-	};
-}
-
-// Cross-thread function registry (project plan, Phase 6 — worklet
-// substitute). See main-thread.js's registerHandler()/runOnBackground() for
-// the full rationale; this is the mirror image for the reverse direction.
-// Lazy setup on first use, same reasoning as main-thread.js.
-const backgroundHandlers = new Map();
-const pendingMainThreadCalls = new Map();
-let nextCallId = 1;
-let crossThreadCallsReady = false;
-
-function ensureCrossThreadCalls() {
-	if (crossThreadCallsReady) return;
-	crossThreadCallsReady = true;
-	const coreContext = lynx.getCoreContext();
-
-	coreContext.addEventListener(callBackgroundEventName, (event) => {
-		const { callId, key, args } = event.data;
-		const fn = backgroundHandlers.get(key);
-		let result;
-		let error;
-		try {
-			result = fn ? fn(...args) : undefined;
-		} catch (e) {
-			error = e instanceof Error ? e.message : String(e);
-		}
-		coreContext.dispatchEvent({ type: callBackgroundResultEventName, data: { callId, result, error } });
-	});
-
-	coreContext.addEventListener(callMainThreadResultEventName, (event) => {
-		const { callId, result, error } = event.data;
-		const pending = pendingMainThreadCalls.get(callId);
-		if (pending == null) return;
-		pendingMainThreadCalls.delete(callId);
-		if (error != null) pending.reject(new Error(error));
-		else pending.resolve(result);
-	});
-}
-
-/** Registers a handler main-thread.js's runOnBackground(key, ...) can call by name. */
-export function registerHandler(key, fn) {
-	ensureCrossThreadCalls();
-	backgroundHandlers.set(key, fn);
-}
-
-/** Calls a handler main-thread.js registered via registerHandler(key, fn), by name. Args must be JSON-serializable. */
-export function runOnMainThread(key, ...args) {
-	ensureCrossThreadCalls();
-	return new Promise((resolve, reject) => {
-		const callId = nextCallId++;
-		pendingMainThreadCalls.set(callId, { resolve, reject });
-		lynx.getCoreContext().dispatchEvent({ type: callMainThreadEventName, data: { callId, key, args } });
-	});
-}

package/element.d.ts

@@ -1,34 +0,0 @@
-// Ambient declaration for the ESM element.js (the file itself is not
-// type-checked; this describes its runtime export shape for TS consumers).
-
-export interface SelectorParams {
-  onlyCurrentComponent?: boolean;
-}
-
-export interface AnimationTimingOptions {
-  name?: string;
-  duration?: number | string;
-  delay?: number | string;
-  iterationCount?: number | string;
-  fillMode?: string;
-  timingFunction?: string;
-  direction?: string;
-}
-
-export type Keyframe = Record<string, string | number>;
-
-export interface MainThreadElement {
-  setStyleProperty(name: string, value: string | number): void;
-  setStyleProperties(styles: Record<string, string | number>): void;
-  setAttribute(name: string, value: unknown): void;
-  querySelector(selector: string, params?: SelectorParams): MainThreadElement | null;
-  querySelectorAll(selector: string, params?: SelectorParams): MainThreadElement[];
-  animate(keyframes: Keyframe[], options?: AnimationTimingOptions): void;
-  playAnimation(name: string): void;
-  pauseAnimation(name: string): void;
-  cancelAnimation(name: string): void;
-  invoke(method: string, params?: Record<string, unknown>): Promise<{ code: number; data: unknown }>;
-}
-
-/** Wraps a node (anything with a `_handle`, i.e. a real LynxNodeWrapper) with imperative PAPI methods. */
-export function wrapElement(node: { _handle: unknown }): MainThreadElement;

package/element.js

@@ -1,83 +0,0 @@
-// element.js
-//
-// Ergonomic imperative escape hatch for a main-thread node — whatever
-// Mithril's oncreate(vnode)/onupdate(vnode) hooks hand you as `vnode.dom`
-// (works for any real LynxNodeWrapper: main-thread-owned mode, or
-// data-channel mode's main-thread half). Not part of render.js's own DOM
-// contract (see ../CONTRACT.md) — these are Element PAPI capabilities apps
-// reach for directly (focusing a native input, animating, calling a native
-// custom element's method), so they live in their own small module instead
-// of the shim.
-//
-// Project plan, Phase 5. Background-thread refs are the selector-query
-// equivalent — see background.js's createRef().
-
-const ANIMATION_OPERATION = { START: 0, PLAY: 1, PAUSE: 2, CANCEL: 3 };
-
-function wrapRef(handle) {
-	return handle == null ? null : wrapElement({ _handle: handle });
-}
-
-/**
- * Wraps a node (anything with a `_handle`, i.e. a real LynxNodeWrapper OR a
- * raw ElementRef from querySelector) with imperative PAPI methods render.js
- * itself never needs. setAttribute mirrors the real LynxNodeWrapper's own
- * class/id/data-prefixed/generic-attribute special-casing (see
- * ../CONTRACT.md) rather than delegating to node.setAttribute() directly —
- * a raw querySelector result has no such method, only a `_handle`.
- */
-export function wrapElement(node) {
-	const handle = node._handle;
-
-	return {
-		setStyleProperty(name, value) {
-			__SetInlineStyles(handle, { [name]: value });
-		},
-
-		setStyleProperties(styles) {
-			__SetInlineStyles(handle, styles);
-		},
-
-		setAttribute(name, value) {
-			// "" not undefined when clearing: real hardware's FiberSetClasses
-			// rejects a non-string argument ("FiberSetClasses param 1 should be
-			// String") — see lynx-mithril-shim.js's own matching fix for the
-			// same call.
-			if (name === "class") __SetClasses(handle, value == null ? "" : String(value));
-			else if (name === "id") __SetID(handle, value == null ? null : String(value));
-			else if (name.slice(0, 5) === "data-") __AddDataset(handle, name.slice(5), value);
-			else __SetAttribute(handle, name, value == null ? null : value);
-		},
-
-		querySelector(selector, params) {
-			return wrapRef(__QuerySelector(handle, selector, params || {}));
-		},
-
-		querySelectorAll(selector, params) {
-			return __QuerySelectorAll(handle, selector, params || {}).map((ref) => wrapRef(ref));
-		},
-
-		animate(keyframes, options) {
-			__ElementAnimate(handle, [ANIMATION_OPERATION.START, (options && options.name) || "", keyframes, options]);
-		},
-
-		playAnimation(name) {
-			__ElementAnimate(handle, [ANIMATION_OPERATION.PLAY, name]);
-		},
-
-		pauseAnimation(name) {
-			__ElementAnimate(handle, [ANIMATION_OPERATION.PAUSE, name]);
-		},
-
-		cancelAnimation(name) {
-			__ElementAnimate(handle, [ANIMATION_OPERATION.CANCEL, name]);
-		},
-
-		/** Always resolves with { code, data } — check `code` yourself; PAPI's success/failure convention isn't assumed here. */
-		invoke(method, params) {
-			return new Promise((resolve) => {
-				__InvokeUIMethod(handle, method, params || {}, (res) => resolve(res));
-			});
-		},
-	};
-}

package/gesture.d.ts

@@ -1,40 +0,0 @@
-// Ambient declaration for the ESM gesture.js (the file itself is not
-// type-checked; this describes its runtime export shape for TS consumers).
-
-export const GestureType: {
-  readonly COMPOSED: -1;
-  readonly PAN: 0;
-  readonly FLING: 1;
-  readonly DEFAULT: 2;
-  readonly TAP: 3;
-  readonly LONGPRESS: 4;
-  readonly ROTATION: 5;
-  readonly PINCH: 6;
-  readonly NATIVE: 7;
-};
-
-export type GestureTypeName = keyof typeof GestureType;
-
-export interface Gesture {
-  id: number;
-  remove(): void;
-  setState(state: number): void;
-}
-
-export interface GestureController {
-  __SetGestureState(state: number): void;
-  __ConsumeGesture(options: Record<string, boolean>): void;
-}
-
-export interface CreateGestureOptions {
-  type: number | GestureTypeName;
-  /** Each callback is invoked as `(event, controller) => {}`; `controller` can usually be ignored. */
-  callbacks?: Record<string, (event: unknown, controller: GestureController) => unknown>;
-  waitFor?: Gesture[];
-  simultaneousWith?: Gesture[];
-  continueWith?: Gesture[];
-  config?: Record<string, unknown>;
-}
-
-/** Registers a gesture detector on a node (anything with a `_handle`). See the project plan, Phase 7. */
-export function createGesture(node: { _handle: unknown }, options: CreateGestureOptions): Gesture;