@lingxia/elements 0.15.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingxia/elements",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "private": false,
   "description": "LingXia custom elements — native-backed web components for LxApp pages",
   "type": "module",
@@ -15,6 +15,7 @@
   },
   "scripts": {
     "build": "npm --prefix ../lingxia-bridge run build:types && tsc -p tsconfig.json",
+    "test:inline-native": "npm run build && node tests/inline-native-structure.mjs && node tests/inline-native-unwrap.mjs && node tests/inline-native-runtime.mjs && node tests/inline-native-events.mjs && node tests/inline-native-style.mjs && node tests/video-events.mjs && node tests/inline-native-identity.mjs && node tests/inline-native-contract.mjs",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build"
   },

package/src/index.ts

@@ -2,6 +2,8 @@ export {
   registerVideoComponent,
   LxVideoElement,
   type LxVideoAttributes,
+  type LxVideoEventPayloads,
+  type LxVideoEventHandlers,
 } from "./video.js";
 
 export {
@@ -38,7 +40,7 @@ export {
   LxNavigatorElement,
   type LxNavigatorAttributes,
   type LxNavigatorEvent,
-  type NavigatorEnvVersion,
+  type NavigatorChannel,
   type NavigatorOpenType,
   type NavigatorQuery,
   type NavigatorQueryValue,
@@ -71,3 +73,58 @@ export {
   NativeComponentUpdateState,
   type Rect,
 } from "./component.js";
+
+export {
+  INLINE_NATIVE_SCHEMA,
+  NATIVE_ERROR_CODES,
+  PUBLIC_COMPONENT_NAMES,
+  PUBLIC_ELEMENT_TAGS,
+  CORE_KINDS,
+  HOST_FACTORY_KINDS,
+  compileInlineNativeRoot,
+  compileInlineNativeForest,
+  identifyCompiledRoot,
+  buildRootCommit,
+  buildGeometrySnapshot,
+  publishCompiledRoot,
+  applyHostLeaseMessage,
+  createRootRuntimeState,
+  viewCanShowFallback,
+  collectVideoResourceUrls,
+  buildVideoCommandRequest,
+  collectAuthorTreeFromElement,
+  normalizeAuthorType,
+  parseBooleanAttr,
+  unwrapNativeEventPayload,
+  bindPayloadHandler,
+  nativeError,
+  registerInlineNativeComponents,
+  registerInlineNativeAuthorComponents,
+  registerNativeRootComponent,
+  registerNativeViewComponent,
+  registerNativeCoverComponent,
+  registerNativeTextComponent,
+  registerNativeButtonComponent,
+  LxNativeRootElement,
+  LxNativeViewElement,
+  LxNativeCoverElement,
+  LxNativeTextElement,
+  LxNativeButtonElement,
+  EMPTY_ROOT_REF,
+  type NativeErrorCode,
+  type PublicComponentName,
+  type RootRef,
+  type NodeRef,
+  type NativeError,
+  type AuthorNode,
+  type CoreNode,
+  type CompiledNativeRoot,
+  type CompileInlineNativeResult,
+  type PressPayload,
+  type ValuePayload,
+  type FocusPayload,
+  type PointerPayload,
+  type NativeHandler,
+  type NativeActionIcon,
+  type NativeStyleProperty,
+} from "./inline-native/index.js";

package/src/inline-native/commit.ts

@@ -0,0 +1,141 @@
+import type { IdentifiedNode, IdentifiedRoot } from "./identity.js";
+import type { RootRef } from "./types.js";
+
+export interface NativeRootCommitJson {
+  action: "root.commit";
+  root: RootRef;
+  baseRevision: number;
+  revision: number;
+  operations: NativeRootOperationJson[];
+}
+
+export type NativeRootOperationJson =
+  | { op: "mount"; node: NativeNodeJson }
+  | { op: "update"; node: IdentifiedNode["nodeRef"]; patch: Record<string, unknown> }
+  | { op: "reparent"; node: IdentifiedNode["nodeRef"]; parent: IdentifiedNode["nodeRef"] | null }
+  | { op: "reorder"; node: IdentifiedNode["nodeRef"]; order: number }
+  | { op: "unmount"; node: IdentifiedNode["nodeRef"] };
+
+export interface NativeNodeJson {
+  ref: IdentifiedNode["nodeRef"];
+  kind: string;
+  parent: IdentifiedNode["nodeRef"] | null;
+  order: number;
+  authorType: string;
+  authorId?: string;
+  automationId?: string;
+  props: Record<string, unknown>;
+}
+
+export function buildRootCommit(
+  next: IdentifiedRoot,
+  previous: IdentifiedRoot | null,
+  revision: number
+): NativeRootCommitJson {
+  const baseRevision = previous ? revision - 1 : 0;
+  const operations: NativeRootOperationJson[] = [];
+  const prevIndex = previous ? indexIdentified(previous) : new Map<string, IdentifiedNode>();
+  const nextIndex = indexIdentified(next);
+
+  walkMounts(next.children, prevIndex, operations);
+
+  for (const [key, current] of nextIndex) {
+    const prev = prevIndex.get(key);
+    if (!prev) continue;
+    if (parentKey(prev) !== parentKey(current)) {
+      operations.push({
+        op: "reparent",
+        node: current.nodeRef,
+        parent: current.parentRef,
+      });
+    }
+    if (prev.order !== current.order) {
+      operations.push({ op: "reorder", node: current.nodeRef, order: current.order });
+    }
+    const patch = propsPatch(effectiveProps(prev), effectiveProps(current));
+    if (patch) {
+      operations.push({ op: "update", node: current.nodeRef, patch });
+    }
+  }
+
+  // Retained children must leave removed parents before the host cascades unmount.
+  for (const [key, prev] of prevIndex) {
+    if (!nextIndex.has(key)) {
+      operations.push({ op: "unmount", node: prev.nodeRef });
+    }
+  }
+
+
+  return {
+    action: "root.commit",
+    root: next.rootRef,
+    baseRevision,
+    revision,
+    operations,
+  };
+}
+
+function walkMounts(
+  nodes: readonly IdentifiedNode[],
+  prevIndex: Map<string, IdentifiedNode>,
+  operations: NativeRootOperationJson[]
+): void {
+  for (const node of nodes) {
+    if (!prevIndex.has(node.nodeRef.nodeKey)) {
+      operations.push({
+        op: "mount",
+        node: {
+          ref: node.nodeRef,
+          kind: node.node.kind,
+          parent: node.parentRef,
+          order: node.order,
+          authorType: node.node.authorType,
+          authorId: node.node.authorId,
+          automationId: node.node.automationId,
+          props: effectiveProps(node),
+        },
+      });
+    }
+    walkMounts(node.children, prevIndex, operations);
+  }
+}
+
+function indexIdentified(root: IdentifiedRoot): Map<string, IdentifiedNode> {
+  const map = new Map<string, IdentifiedNode>();
+  const walk = (nodes: readonly IdentifiedNode[]) => {
+    for (const node of nodes) {
+      map.set(node.nodeRef.nodeKey, node);
+      walk(node.children);
+    }
+  };
+  walk(root.children);
+  return map;
+}
+
+function parentKey(node: IdentifiedNode): string {
+  return node.parentRef?.nodeKey ?? "";
+}
+
+/// `text` is a sibling of `props` on the core node, but the host reads it from
+/// props. Fold it in for both the mount and the diff, or a caption that changes
+/// after mount emits no update and the host keeps painting the first string.
+function effectiveProps(node: IdentifiedNode): Record<string, unknown> {
+  return node.node.text !== undefined
+    ? { ...node.node.props, text: node.node.text }
+    : node.node.props;
+}
+
+function propsPatch(
+  prev: Record<string, unknown>,
+  next: Record<string, unknown>
+): Record<string, unknown> | null {
+  const patch: Record<string, unknown> = {};
+  let changed = false;
+  const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+  for (const key of keys) {
+    if (JSON.stringify(prev[key]) === JSON.stringify(next[key])) continue;
+    patch[key] = next[key] === undefined ? null : next[key];
+    changed = true;
+  }
+  return changed ? patch : null;
+}