@lingxia/elements 0.15.0 → 0.17.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export { registerVideoComponent, LxVideoElement, type LxVideoAttributes, } from "./video.js";
+export { registerVideoComponent, LxVideoElement, type LxVideoAttributes, type LxVideoEventPayloads, type LxVideoEventHandlers, } from "./video.js";
 export { registerMediaSwiperComponent, LxMediaSwiperElement, type LxMediaSwiperAttributes, type LxMediaSwiperItem, type LxMediaSwiperChangeEvent, type LxMediaSwiperChangeEventDetail, type LxMediaSwiperTransitionEndEvent, type LxMediaSwiperTransitionEndEventDetail, type LxMediaSwiperItemEvent, type LxMediaSwiperEventDetail, type LxMediaSwiperEndReachedEvent, type LxMediaSwiperEndReachedEventDetail, type LxMediaSwiperErrorEvent, type LxMediaSwiperErrorEventDetail, type LxMediaSwiperChangeSource, type LxMediaSwiperErrorCode, } from "./media_swiper.js";
 export { registerPickerComponent, LxPickerElement, type LxPickerAttributes, type LxPickerColumn, type LxPickerCascadingColumns, type LxPickerEvent, type LxPickerEventDetail, } from "./picker.js";
-export { LxNavigatorElement, type LxNavigatorAttributes, type LxNavigatorEvent, type NavigatorEnvVersion, type NavigatorOpenType, type NavigatorQuery, type NavigatorQueryValue, type NavigatorTarget, } from "./navigator.js";
+export { LxNavigatorElement, type LxNavigatorAttributes, type LxNavigatorEvent, type NavigatorChannel, type NavigatorOpenType, type NavigatorQuery, type NavigatorQueryValue, type NavigatorTarget, } from "./navigator.js";
 export { buildVideoNativeAttrs, buildMediaSwiperNativeAttrs, buildNavigatorNativeAttrs, buildPickerNativeAttrs, getPickerDisplayText, getPickerValueFromIndex, VIDEO_DOM_EVENT_MAP, MEDIA_SWIPER_DOM_EVENT_MAP, } from "./native_component_wrapper_shared.js";
 export { isHarmony, isIOS, isAndroid, isMacOS, isDesktop, getOS, } from "./platform.js";
 export { ensureComponentId, rectEquals, 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/dist/index.js

@@ -5,3 +5,4 @@ export { LxNavigatorElement, } from "./navigator.js";
 export { buildVideoNativeAttrs, buildMediaSwiperNativeAttrs, buildNavigatorNativeAttrs, buildPickerNativeAttrs, getPickerDisplayText, getPickerValueFromIndex, VIDEO_DOM_EVENT_MAP, MEDIA_SWIPER_DOM_EVENT_MAP, } from "./native_component_wrapper_shared.js";
 export { isHarmony, isIOS, isAndroid, isMacOS, isDesktop, getOS, } from "./platform.js";
 export { ensureComponentId, rectEquals, NativeComponentUpdateState, } 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, } from "./inline-native/index.js";

package/dist/inline-native/commit.d.ts

@@ -0,0 +1,39 @@
+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 declare function buildRootCommit(next: IdentifiedRoot, previous: IdentifiedRoot | null, revision: number): NativeRootCommitJson;

package/dist/inline-native/commit.js

@@ -0,0 +1,94 @@
+export function buildRootCommit(next, previous, revision) {
+    const baseRevision = previous ? revision - 1 : 0;
+    const operations = [];
+    const prevIndex = previous ? indexIdentified(previous) : new Map();
+    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, prevIndex, operations) {
+    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) {
+    const map = new Map();
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            map.set(node.nodeRef.nodeKey, node);
+            walk(node.children);
+        }
+    };
+    walk(root.children);
+    return map;
+}
+function parentKey(node) {
+    var _a, _b;
+    return (_b = (_a = node.parentRef) === null || _a === void 0 ? void 0 : _a.nodeKey) !== null && _b !== void 0 ? _b : "";
+}
+/// `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) {
+    return node.node.text !== undefined
+        ? { ...node.node.props, text: node.node.text }
+        : node.node.props;
+}
+function propsPatch(prev, next) {
+    const patch = {};
+    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;
+}

package/dist/inline-native/elements.d.ts

@@ -0,0 +1,104 @@
+import type { CompileInlineNativeResult, NativeError } from "./types.js";
+declare class LxNativeBaseElement extends HTMLElement {
+    static get observedAttributes(): string[];
+    connectedCallback(): void;
+    get automationId(): string | null;
+    set automationId(value: string | null | undefined);
+    get pointerEvents(): string | null;
+    set pointerEvents(value: string | null | undefined);
+}
+export declare class LxNativeRootElement extends LxNativeBaseElement {
+    static get observedAttributes(): string[];
+    private pending;
+    private observer?;
+    private documentObserver?;
+    private resizeObserver?;
+    private stopLayoutObservation?;
+    private lastResult;
+    private styleDiagnostics;
+    private rootKey;
+    private rootEpoch;
+    private runtime;
+    private unregisterHost?;
+    private fallbackTimer;
+    lastCompileResult(): CompileInlineNativeResult | null;
+    retry(): Promise<void>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private scheduleCompile;
+    compileNow(): CompileInlineNativeResult;
+    private compileMeasured;
+    private onHostMessage;
+    private armFallbackDeadline;
+    private updateFallbackVisibility;
+    private rootRef;
+    private destroyPublishedRoot;
+    private onViewportGeometryChanged;
+    private syncResizeObservation;
+}
+export declare class LxNativeViewElement extends LxNativeBaseElement {
+    static get observedAttributes(): string[];
+}
+export declare class LxNativeCoverElement extends LxNativeBaseElement {
+    static get observedAttributes(): string[];
+    connectedCallback(): void;
+    get scrim(): string;
+    set scrim(value: string | null | undefined);
+    get scrimOpacity(): number;
+    set scrimOpacity(value: number | string | null | undefined);
+}
+export declare class LxNativeTextElement extends LxNativeBaseElement {
+    private typography?;
+    static get observedAttributes(): string[];
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    private syncTypography;
+    get maxLines(): number | null;
+    set maxLines(value: number | string | null | undefined);
+}
+export declare class LxNativeButtonElement extends LxNativeBaseElement {
+    private unregisterHost?;
+    private registeredId?;
+    private measuredLabel?;
+    private measuredIcon?;
+    private contentSlot?;
+    private dispatchAccessiblePress;
+    private readonly onAccessibleClick;
+    private readonly onAccessibleKeyDown;
+    connectedCallback(): void;
+    private registerEventBridge;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    private syncMeasurement;
+    private syncAccessibility;
+    static get observedAttributes(): string[];
+    get label(): string | null;
+    set label(value: string | null | undefined);
+    get icon(): string | null;
+    set icon(value: string | null | undefined);
+    get disabled(): boolean;
+    set disabled(value: unknown);
+    get pressed(): boolean;
+    set pressed(value: unknown);
+    get expanded(): boolean;
+    set expanded(value: unknown);
+    get loading(): boolean;
+    set loading(value: unknown);
+}
+export declare function registerNativeRootComponent(): void;
+export declare function registerNativeViewComponent(): void;
+export declare function registerNativeCoverComponent(): void;
+export declare function registerNativeTextComponent(): void;
+export declare function registerNativeButtonComponent(): void;
+export declare function registerInlineNativeAuthorComponents(): void;
+export declare function structureErrorFromUnknown(message: string): NativeError;
+declare global {
+    interface HTMLElementTagNameMap {
+        "lx-native-root": LxNativeRootElement;
+        "lx-native-view": LxNativeViewElement;
+        "lx-native-cover": LxNativeCoverElement;
+        "lx-native-text": LxNativeTextElement;
+        "lx-native-button": LxNativeButtonElement;
+    }
+}
+export {};