@seed-design/lynx-react 0.3.1 → 0.4.1

package/lib/components/KeyboardAvoidingScrollView/engine.js

@@ -0,0 +1,259 @@
+import { calculateSafeArea, calculateSignedScrollDelta, clampScrollOffset, createFieldBodyRect, hasMeaningfulGeometryChange, selectLargestFittingTarget } from "./geometry.js";
+//#region src/components/KeyboardAvoidingScrollView/engine.ts
+var BLUR_HANDOFF_DELAY_MS = 30;
+function normalizeKeyboardState(state) {
+	const height = Number.isFinite(state.height) ? Math.max(0, state.height) : 0;
+	const visible = state.visible && height > 0;
+	return {
+		visible,
+		height: visible ? height : 0
+	};
+}
+function targetHeight(rect) {
+	return Math.max(0, rect.bottom - rect.top);
+}
+var KeyboardAvoidingEngineImpl = class {
+	#options;
+	#pendingReasons = /* @__PURE__ */ new Set();
+	#ownerStates = /* @__PURE__ */ new Map();
+	#activeRegistration = null;
+	#keyboard = {
+		visible: false,
+		height: 0
+	};
+	#revision = 0;
+	#session = 0;
+	#appliedSpacerHeight = 0;
+	#needsCloseClamp = false;
+	#cancelFrame = null;
+	#cancelBlur = null;
+	#blurOwner = null;
+	#userScrolling = false;
+	#disposed = false;
+	constructor(options) {
+		this.#options = options;
+	}
+	focus(registration) {
+		if (this.#disposed) return;
+		this.#cancelPendingBlur();
+		if (registration.enabled === false) {
+			if (this.#activeRegistration === null) return;
+			this.#activeRegistration = null;
+			this.#invalidate("focus");
+			return;
+		}
+		this.#activeRegistration = registration;
+		this.#invalidate("focus");
+	}
+	blur(owner) {
+		if (this.#disposed || this.#activeRegistration?.owner !== owner) return;
+		this.#cancelPendingBlur();
+		this.#blurOwner = owner;
+		this.#cancelBlur = this.#options.scheduler.scheduleTimer(() => {
+			this.#cancelBlur = null;
+			const blurOwner = this.#blurOwner;
+			this.#blurOwner = null;
+			if (this.#activeRegistration?.owner !== blurOwner) return;
+			this.#activeRegistration = null;
+			this.#invalidate("focus");
+		}, BLUR_HANDOFF_DELAY_MS);
+	}
+	layoutChanged(owner) {
+		if (this.#disposed || this.#activeRegistration?.owner !== owner) return;
+		this.#invalidate("layout");
+	}
+	unregister(owner) {
+		if (this.#disposed) return;
+		this.#ownerStates.delete(owner);
+		if (this.#blurOwner === owner) this.#cancelPendingBlur();
+		if (this.#activeRegistration?.owner !== owner) return;
+		this.#activeRegistration = null;
+		this.#invalidate("focus");
+	}
+	keyboardChanged(state) {
+		if (this.#disposed) return;
+		const next = normalizeKeyboardState(state);
+		if (next.visible === this.#keyboard.visible && !hasMeaningfulGeometryChange(this.#keyboard.height, next.height)) return;
+		if (next.visible !== this.#keyboard.visible) {
+			this.#session += 1;
+			this.#ownerStates.clear();
+		}
+		this.#keyboard = next;
+		this.#invalidate("keyboard");
+	}
+	viewportChanged() {
+		if (this.#disposed) return;
+		this.#invalidate("viewport");
+	}
+	userScrollStarted() {
+		if (this.#disposed || this.#userScrolling) return;
+		this.#userScrolling = true;
+		this.#revision += 1;
+		this.#pendingReasons.add("scroll");
+		this.#cancelFrame?.();
+		this.#cancelFrame = null;
+	}
+	userScrollEnded() {
+		if (this.#disposed || !this.#userScrolling) return;
+		this.#userScrolling = false;
+		this.#invalidate("scroll");
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#revision += 1;
+		this.#cancelFrame?.();
+		this.#cancelFrame = null;
+		this.#cancelPendingBlur();
+		this.#pendingReasons.clear();
+		this.#ownerStates.clear();
+		this.#activeRegistration = null;
+	}
+	#cancelPendingBlur() {
+		this.#cancelBlur?.();
+		this.#cancelBlur = null;
+		this.#blurOwner = null;
+	}
+	#invalidate(reason) {
+		this.#revision += 1;
+		this.#pendingReasons.add(reason);
+		if (this.#userScrolling || this.#cancelFrame !== null) return;
+		this.#cancelFrame = this.#options.scheduler.scheduleFrame(async () => {
+			this.#cancelFrame = null;
+			if (this.#disposed || this.#userScrolling) return;
+			const reasons = new Set(this.#pendingReasons);
+			this.#pendingReasons.clear();
+			const transaction = {
+				revision: this.#revision,
+				session: this.#session,
+				registration: this.#activeRegistration,
+				keyboard: this.#keyboard,
+				layoutOnly: reasons.size === 1 && reasons.has("layout")
+			};
+			await this.#evaluate(transaction);
+		});
+	}
+	#isCurrent(transaction) {
+		return !this.#disposed && transaction.revision === this.#revision && transaction.session === this.#session && transaction.registration === this.#activeRegistration && !this.#userScrolling;
+	}
+	async #evaluate(transaction) {
+		try {
+			if (!transaction.keyboard.visible || transaction.registration === null) {
+				await this.#close(transaction);
+				return;
+			}
+			await this.#open(transaction, transaction.registration);
+		} catch {}
+	}
+	async #close(transaction) {
+		if (this.#appliedSpacerHeight === 0 && !this.#needsCloseClamp) return;
+		const scrollNode = this.#options.getScrollNode();
+		if (this.#appliedSpacerHeight !== 0) {
+			const spacerNode = this.#options.getSpacerNode();
+			if (spacerNode === null) return;
+			this.#options.driver.setSpacerHeight(spacerNode, 0);
+			this.#appliedSpacerHeight = 0;
+			this.#needsCloseClamp = true;
+		}
+		if (scrollNode === null) return;
+		await this.#options.driver.waitForLayout();
+		if (!this.#isCurrent(transaction)) return;
+		const viewport = await this.#options.driver.measure(scrollNode);
+		if (!this.#isCurrent(transaction) || viewport === null) return;
+		const viewportHeight = Math.max(0, viewport.bottom - viewport.top);
+		const metrics = await this.#options.driver.getScrollMetrics(scrollNode, viewportHeight);
+		if (!this.#isCurrent(transaction) || metrics === null) return;
+		const clampedOffset = clampScrollOffset(metrics.offsetY, metrics.maxOffsetY);
+		if (clampedOffset === metrics.offsetY) {
+			this.#needsCloseClamp = false;
+			return;
+		}
+		this.#options.driver.scrollTo(scrollNode, clampedOffset, this.#options.getSmooth());
+		this.#needsCloseClamp = false;
+	}
+	async #open(transaction, registration) {
+		const scrollNode = this.#options.getScrollNode();
+		const spacerNode = this.#options.getSpacerNode();
+		if (scrollNode === null || spacerNode === null) return;
+		const [viewport, occlusion] = await Promise.all([this.#options.driver.measure(scrollNode), this.#options.driver.resolveKeyboardOcclusion(transaction.keyboard)]);
+		if (!this.#isCurrent(transaction) || viewport === null || occlusion === null) return;
+		const safeArea = calculateSafeArea({
+			viewport,
+			keyboardOcclusionTop: occlusion.topInScreenPx,
+			toolbarHeight: this.#options.getToolbarHeight(),
+			keyboardGap: this.#options.getKeyboardGap()
+		});
+		this.#needsCloseClamp = false;
+		if (hasMeaningfulGeometryChange(this.#appliedSpacerHeight, safeArea.spacerHeight)) {
+			this.#options.driver.setSpacerHeight(spacerNode, safeArea.spacerHeight);
+			this.#appliedSpacerHeight = safeArea.spacerHeight;
+		}
+		await this.#options.driver.waitForLayout();
+		if (!this.#isCurrent(transaction)) return;
+		const state = this.#getOwnerState(registration.owner, transaction.session);
+		const measure = (ref) => {
+			const node = ref?.current;
+			if (node === null || node === void 0) return Promise.resolve(null);
+			return Promise.resolve().then(() => this.#options.driver.measure(node)).catch(() => null);
+		};
+		const [field, control, native, anchor] = await Promise.all([
+			state.fieldDowngraded ? Promise.resolve(null) : measure(registration.fieldRef),
+			measure(registration.controlRef),
+			measure(registration.nativeRef),
+			measure(registration.anchorRef)
+		]);
+		if (!this.#isCurrent(transaction)) return;
+		const fieldBody = createFieldBodyRect(field, control);
+		const selected = selectLargestFittingTarget({
+			field,
+			fieldBody,
+			control,
+			native,
+			anchor
+		}, safeArea);
+		const nextState = {
+			...state,
+			fieldDowngraded: state.fieldDowngraded || fieldBody === null && field !== null && selected !== null && selected.kind !== "field",
+			lastTargetKind: selected?.kind ?? null,
+			lastTargetHeight: selected ? targetHeight(selected.rect) : null
+		};
+		if (selected === null) {
+			this.#ownerStates.set(registration.owner, nextState);
+			return;
+		}
+		if (transaction.layoutOnly && (state.lastTargetKind === selected.kind && state.lastTargetHeight !== null && targetHeight(selected.rect) < state.lastTargetHeight - 1 || state.lastTargetKind === "fieldBottom" && selected.kind !== "fieldBottom")) {
+			this.#ownerStates.set(registration.owner, nextState);
+			return;
+		}
+		const delta = calculateSignedScrollDelta(selected.rect, safeArea);
+		if (delta === 0) {
+			this.#ownerStates.set(registration.owner, nextState);
+			return;
+		}
+		const viewportHeight = Math.max(0, viewport.bottom - viewport.top);
+		const metrics = await this.#options.driver.getScrollMetrics(scrollNode, viewportHeight);
+		if (!this.#isCurrent(transaction) || metrics === null) return;
+		const nextOffset = clampScrollOffset(metrics.offsetY + delta, metrics.maxOffsetY);
+		if (!hasMeaningfulGeometryChange(metrics.offsetY, nextOffset)) {
+			this.#ownerStates.set(registration.owner, nextState);
+			return;
+		}
+		this.#options.driver.scrollTo(scrollNode, nextOffset, this.#options.getSmooth());
+		this.#ownerStates.set(registration.owner, nextState);
+	}
+	#getOwnerState(owner, session) {
+		const current = this.#ownerStates.get(owner);
+		if (current?.session === session) return current;
+		return {
+			session,
+			fieldDowngraded: false,
+			lastTargetKind: null,
+			lastTargetHeight: null
+		};
+	}
+};
+function createKeyboardAvoidingEngine(options) {
+	return new KeyboardAvoidingEngineImpl(options);
+}
+//#endregion
+export { createKeyboardAvoidingEngine };

package/lib/components/KeyboardAvoidingScrollView/geometry.d.ts

@@ -0,0 +1,50 @@
+export declare const KEYBOARD_AVOIDANCE_EPSILON_PX = 1;
+export interface VerticalRect {
+    top: number;
+    bottom: number;
+}
+export interface SafeArea {
+    safeTop: number;
+    safeBottom: number;
+    spacerHeight: number;
+}
+export interface CalculateSafeAreaOptions {
+    viewport: VerticalRect;
+    keyboardOcclusionTop: number;
+    toolbarHeight: number;
+    keyboardGap: number;
+}
+export type AvoidanceTargetKind = "field" | "fieldBody" | "control" | "native" | "anchor" | "fieldBottom";
+export interface AvoidanceTarget {
+    kind: AvoidanceTargetKind;
+    rect: VerticalRect;
+}
+export interface AvoidanceTargetCandidates {
+    field?: VerticalRect | null;
+    fieldBody?: VerticalRect | null;
+    control?: VerticalRect | null;
+    native?: VerticalRect | null;
+    anchor?: VerticalRect | null;
+}
+/**
+ * screen 좌표계에서 키보드와 툴바가 가리지 않는 세로 영역을 계산한다.
+ */
+export declare function calculateSafeArea({ viewport, keyboardOcclusionTop, toolbarHeight, keyboardGap, }: CalculateSafeAreaOptions): SafeArea;
+/**
+ * Field의 header를 제외하고 control부터 footer까지 포함하는 영역을 만든다.
+ */
+export declare function createFieldBodyRect(field: VerticalRect | null, control: VerticalRect | null, epsilon?: number): VerticalRect | null;
+/**
+ * 화면에 온전히 들어오는 가장 큰 의미 단위를 선택한다.
+ * 우선순위는 Field, Field body, Field bottom, control, native control, 정밀 anchor 순이다.
+ * Field body가 너무 크면 autoresize Field의 footer를 추적할 수 있도록
+ * control보다 먼저 Field body의 하단점을 사용한다.
+ */
+export declare function selectLargestFittingTarget(candidates: AvoidanceTargetCandidates, safeArea: Pick<SafeArea, "safeTop" | "safeBottom">, epsilon?: number): AvoidanceTarget | null;
+/**
+ * 양수는 아래로, 음수는 위로 이동해야 하는 scroll offset 변화량이다.
+ */
+export declare function calculateSignedScrollDelta(target: VerticalRect, safeArea: Pick<SafeArea, "safeTop" | "safeBottom">, epsilon?: number): number;
+export declare function clampScrollOffset(offset: number, maxOffset: number): number;
+export declare function hasMeaningfulGeometryChange(previous: number, next: number, epsilon?: number): boolean;
+//# sourceMappingURL=geometry.d.ts.map

package/lib/components/KeyboardAvoidingScrollView/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../src/components/KeyboardAvoidingScrollView/geometry.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,YAAY,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,mBAAmB,GAC3B,OAAO,GACP,WAAW,GACX,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,aAAa,CAAC;AAElB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,EAAE,YAAY,CAAC;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,SAAS,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAChC,OAAO,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,MAAM,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,oBAAoB,EACpB,aAAa,EACb,WAAW,GACZ,EAAE,wBAAwB,GAAG,QAAQ,CAcrC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,YAAY,GAAG,IAAI,EAC1B,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,OAAO,SAAgC,GACtC,YAAY,GAAG,IAAI,CAgBrB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,yBAAyB,EACrC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,YAAY,CAAC,EAClD,OAAO,SAAgC,GACtC,eAAe,GAAG,IAAI,CAwDxB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,YAAY,CAAC,EAClD,OAAO,SAAgC,GACtC,MAAM,CAYR;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,SAAgC,GACtC,OAAO,CAET"}

package/lib/components/KeyboardAvoidingScrollView/geometry.js

@@ -0,0 +1,90 @@
+function normalizeNonNegativeFinite(value) {
+	return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+/**
+* screen 좌표계에서 키보드와 툴바가 가리지 않는 세로 영역을 계산한다.
+*/
+function calculateSafeArea({ viewport, keyboardOcclusionTop, toolbarHeight, keyboardGap }) {
+	const normalizedToolbarHeight = normalizeNonNegativeFinite(toolbarHeight);
+	const normalizedKeyboardGap = normalizeNonNegativeFinite(keyboardGap);
+	const normalizedViewportBottom = Math.max(viewport.top, viewport.bottom);
+	const safeBottom = Math.min(normalizedViewportBottom, Math.max(viewport.top, keyboardOcclusionTop - normalizedToolbarHeight - normalizedKeyboardGap));
+	return {
+		safeTop: viewport.top,
+		safeBottom,
+		spacerHeight: normalizedViewportBottom - safeBottom
+	};
+}
+/**
+* Field의 header를 제외하고 control부터 footer까지 포함하는 영역을 만든다.
+*/
+function createFieldBodyRect(field, control, epsilon = 1) {
+	if (field === null || control === null) return null;
+	const normalizedEpsilon = Math.max(0, epsilon);
+	const fieldHeight = field.bottom - field.top;
+	const controlHeight = control.bottom - control.top;
+	if (fieldHeight < 0 || controlHeight < 0 || control.top < field.top - normalizedEpsilon || control.bottom > field.bottom + normalizedEpsilon) return null;
+	return {
+		top: control.top,
+		bottom: Math.max(field.bottom, control.bottom)
+	};
+}
+/**
+* 화면에 온전히 들어오는 가장 큰 의미 단위를 선택한다.
+* 우선순위는 Field, Field body, Field bottom, control, native control, 정밀 anchor 순이다.
+* Field body가 너무 크면 autoresize Field의 footer를 추적할 수 있도록
+* control보다 먼저 Field body의 하단점을 사용한다.
+*/
+function selectLargestFittingTarget(candidates, safeArea, epsilon = 1) {
+	const availableHeight = Math.max(0, safeArea.safeBottom - safeArea.safeTop);
+	const normalizedEpsilon = Math.max(0, epsilon);
+	const fieldCandidates = [["field", candidates.field], ["fieldBody", candidates.fieldBody]];
+	const fallbackCandidates = [
+		["control", candidates.control],
+		["native", candidates.native],
+		["anchor", candidates.anchor]
+	];
+	for (const [kind, rect] of fieldCandidates) {
+		if (!rect) continue;
+		const targetHeight = rect.bottom - rect.top;
+		if (targetHeight >= 0 && targetHeight <= availableHeight + normalizedEpsilon) return {
+			kind,
+			rect
+		};
+	}
+	const fieldBody = candidates.fieldBody;
+	const fieldBodyHeight = fieldBody ? fieldBody.bottom - fieldBody.top : -1;
+	if (fieldBody && Number.isFinite(fieldBody.top) && Number.isFinite(fieldBody.bottom) && fieldBodyHeight > availableHeight + normalizedEpsilon) return {
+		kind: "fieldBottom",
+		rect: {
+			top: fieldBody.bottom,
+			bottom: fieldBody.bottom
+		}
+	};
+	for (const [kind, rect] of fallbackCandidates) {
+		if (!rect) continue;
+		const targetHeight = rect.bottom - rect.top;
+		if (targetHeight >= 0 && targetHeight <= availableHeight + normalizedEpsilon) return {
+			kind,
+			rect
+		};
+	}
+	return null;
+}
+/**
+* 양수는 아래로, 음수는 위로 이동해야 하는 scroll offset 변화량이다.
+*/
+function calculateSignedScrollDelta(target, safeArea, epsilon = 1) {
+	const normalizedEpsilon = Math.max(0, epsilon);
+	if (target.top < safeArea.safeTop - normalizedEpsilon) return target.top - safeArea.safeTop;
+	if (target.bottom > safeArea.safeBottom + normalizedEpsilon) return target.bottom - safeArea.safeBottom;
+	return 0;
+}
+function clampScrollOffset(offset, maxOffset) {
+	return Math.min(Math.max(0, offset), Math.max(0, maxOffset));
+}
+function hasMeaningfulGeometryChange(previous, next, epsilon = 1) {
+	return Math.abs(next - previous) > Math.max(0, epsilon);
+}
+//#endregion
+export { calculateSafeArea, calculateSignedScrollDelta, clampScrollOffset, createFieldBodyRect, hasMeaningfulGeometryChange, selectLargestFittingTarget };

package/lib/components/KeyboardAvoidingScrollView/index.d.ts

@@ -0,0 +1,2 @@
+export { KeyboardAvoidingScrollView, type KeyboardAvoidingScrollBehavior, type KeyboardAvoidingScrollViewProps, } from './KeyboardAvoidingScrollView';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/KeyboardAvoidingScrollView/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/KeyboardAvoidingScrollView/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,GACrC,MAAM,8BAA8B,CAAC"}

package/lib/components/KeyboardAvoidingScrollView/keyboard-event-source.d.ts

@@ -0,0 +1,11 @@
+import { GlobalEventEmitter } from '@lynx-js/types';
+import { RawKeyboardState } from './native-driver';
+export type KeyboardEventListener = (state: RawKeyboardState) => void;
+export interface KeyboardEventSource {
+    subscribe(listener: KeyboardEventListener): () => void;
+}
+type GetGlobalEventEmitter = () => GlobalEventEmitter;
+export declare function createKeyboardEventSource(getEmitter: GetGlobalEventEmitter): KeyboardEventSource;
+export declare const lynxKeyboardEventSource: KeyboardEventSource;
+export {};
+//# sourceMappingURL=keyboard-event-source.d.ts.map

package/lib/components/KeyboardAvoidingScrollView/keyboard-event-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-event-source.d.ts","sourceRoot":"","sources":["../../../src/components/KeyboardAvoidingScrollView/keyboard-event-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI,CAAC;CACxD;AAED,KAAK,qBAAqB,GAAG,MAAM,kBAAkB,CAAC;AAEtD,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,qBAAqB,GAAG,mBAAmB,CAwDhG;AAED,eAAO,MAAM,uBAAuB,qBAIlC,CAAC"}

package/lib/components/KeyboardAvoidingScrollView/keyboard-event-source.js

@@ -0,0 +1,43 @@
+//#region src/components/KeyboardAvoidingScrollView/keyboard-event-source.ts
+function createKeyboardEventSource(getEmitter) {
+	const subscriptions = /* @__PURE__ */ new Set();
+	let emitter = null;
+	let currentState = {
+		visible: false,
+		height: 0
+	};
+	const handleNativeKeyboardEvent = (...args) => {
+		"background only";
+		const status = args[0];
+		const height = args[1];
+		currentState = {
+			visible: status === "on",
+			height: status === "on" && typeof height === "number" && Number.isFinite(height) ? Math.max(0, height) : 0
+		};
+		for (const subscription of subscriptions) subscription.listener(currentState);
+	};
+	return { subscribe(listener) {
+		"background only";
+		const subscription = { listener };
+		subscriptions.add(subscription);
+		if (emitter === null) try {
+			const nextEmitter = getEmitter();
+			nextEmitter.addListener("keyboardstatuschanged", handleNativeKeyboardEvent);
+			emitter = nextEmitter;
+		} catch {}
+		listener(currentState);
+		let subscribed = true;
+		return () => {
+			"background only";
+			if (!subscribed) return;
+			subscribed = false;
+			subscriptions.delete(subscription);
+		};
+	} };
+}
+var lynxKeyboardEventSource = createKeyboardEventSource(() => {
+	"background only";
+	return lynx.getJSModule("GlobalEventEmitter");
+});
+//#endregion
+export { lynxKeyboardEventSource };

package/lib/components/KeyboardAvoidingScrollView/native-driver.d.ts

@@ -0,0 +1,34 @@
+import { NodesRef, PlatformType } from '@lynx-js/types';
+import { VerticalRect } from './geometry';
+export type KeyboardAvoidingPlatform = Extract<PlatformType, "Android" | "iOS">;
+export interface RawKeyboardState {
+    visible: boolean;
+    height: number;
+}
+export interface KeyboardOcclusion {
+    visible: boolean;
+    topInScreenPx: number;
+}
+export interface ScrollMetrics {
+    offsetY: number;
+    maxOffsetY: number;
+}
+export interface RawScrollInfo {
+    scrollY?: number;
+    scrollRange?: number;
+    maxScrollOffset?: number;
+    scrollTop?: number;
+    scrollHeight?: number;
+}
+export interface KeyboardAvoidingNativeDriver {
+    measure(node: NodesRef): Promise<VerticalRect | null>;
+    resolveKeyboardOcclusion(state: RawKeyboardState): Promise<KeyboardOcclusion | null>;
+    setSpacerHeight(node: NodesRef, height: number): void;
+    waitForLayout(): Promise<void>;
+    getScrollMetrics(node: NodesRef, viewportHeight: number): Promise<ScrollMetrics | null>;
+    scrollTo(node: NodesRef, offset: number, smooth: boolean): void;
+}
+export declare function normalizeScrollMetrics(raw: RawScrollInfo, platform: KeyboardAvoidingPlatform, viewportHeight: number): ScrollMetrics | null;
+export declare function resolveKeyboardOcclusionTop(state: RawKeyboardState, platform: KeyboardAvoidingPlatform, screenHeight: number, rootRect: VerticalRect | null): number | null;
+export declare const lynxKeyboardAvoidingNativeDriver: KeyboardAvoidingNativeDriver;
+//# sourceMappingURL=native-driver.d.ts.map

package/lib/components/KeyboardAvoidingScrollView/native-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-driver.d.ts","sourceRoot":"","sources":["../../../src/components/KeyboardAvoidingScrollView/native-driver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,MAAM,wBAAwB,GAAG,OAAO,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,CAAC,CAAC;AAEhF,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAQD,MAAM,WAAW,4BAA4B;IAC3C,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IACtD,wBAAwB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACrF,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtD,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IACxF,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;CACjE;AAsBD,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,aAAa,EAClB,QAAQ,EAAE,wBAAwB,EAClC,cAAc,EAAE,MAAM,GACrB,aAAa,GAAG,IAAI,CA2BtB;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,gBAAgB,EACvB,QAAQ,EAAE,wBAAwB,EAClC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,YAAY,GAAG,IAAI,GAC5B,MAAM,GAAG,IAAI,CAQf;AA8ED,eAAO,MAAM,gCAAgC,EAAE,4BA2D9C,CAAC"}

package/lib/components/KeyboardAvoidingScrollView/native-driver.js

@@ -0,0 +1,133 @@
+//#region src/components/KeyboardAvoidingScrollView/native-driver.ts
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function normalizeNonNegative(value) {
+	return Math.max(0, value);
+}
+function normalizeRect(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const rect = value;
+	if (!isFiniteNumber(rect.top) || !isFiniteNumber(rect.bottom)) return null;
+	return {
+		top: rect.top,
+		bottom: Math.max(rect.top, rect.bottom)
+	};
+}
+function normalizeScrollMetrics(raw, platform, viewportHeight) {
+	const offsetY = isFiniteNumber(raw.scrollY) ? raw.scrollY : isFiniteNumber(raw.scrollTop) ? raw.scrollTop : null;
+	if (offsetY === null) return null;
+	const normalizedViewportHeight = normalizeNonNegative(viewportHeight);
+	let maxOffsetY = null;
+	if (isFiniteNumber(raw.maxScrollOffset)) maxOffsetY = raw.maxScrollOffset;
+	else if (isFiniteNumber(raw.scrollRange)) maxOffsetY = platform === "iOS" ? raw.scrollRange - normalizedViewportHeight : raw.scrollRange;
+	else if (isFiniteNumber(raw.scrollHeight)) maxOffsetY = platform === "iOS" ? raw.scrollHeight - normalizedViewportHeight : raw.scrollHeight;
+	if (maxOffsetY === null) return null;
+	return {
+		offsetY: normalizeNonNegative(offsetY),
+		maxOffsetY: normalizeNonNegative(maxOffsetY)
+	};
+}
+function resolveKeyboardOcclusionTop(state, platform, screenHeight, rootRect) {
+	if (!state.visible || !isFiniteNumber(state.height) || state.height <= 0) return null;
+	if (platform === "Android") return rootRect ? rootRect.bottom - state.height : null;
+	return isFiniteNumber(screenHeight) && screenHeight > 0 ? screenHeight - state.height : null;
+}
+function getSystemInfo() {
+	const value = globalThis.SystemInfo;
+	if (value?.platform !== "Android" && value?.platform !== "iOS") return null;
+	if (!isFiniteNumber(value.pixelHeight) || !isFiniteNumber(value.pixelRatio)) return null;
+	if (value.pixelHeight <= 0 || value.pixelRatio <= 0) return null;
+	return {
+		platform: value.platform,
+		screenHeight: value.pixelHeight / value.pixelRatio
+	};
+}
+function measureNode(node) {
+	"background only";
+	return new Promise((resolve) => {
+		try {
+			node.invoke({
+				method: "boundingClientRect",
+				params: {
+					relativeTo: "screen",
+					androidEnableTransformProps: true
+				},
+				success: (value) => resolve(normalizeRect(value)),
+				fail: () => resolve(null)
+			}).exec();
+		} catch {
+			resolve(null);
+		}
+	});
+}
+function measureRoot() {
+	"background only";
+	try {
+		return measureNode(lynx.createSelectorQuery().selectRoot());
+	} catch {
+		return Promise.resolve(null);
+	}
+}
+function getScrollMetrics(node, platform, viewportHeight) {
+	"background only";
+	return new Promise((resolve) => {
+		try {
+			node.invoke({
+				method: "getScrollInfo",
+				success: (value) => {
+					if (typeof value !== "object" || value === null) {
+						resolve(null);
+						return;
+					}
+					resolve(normalizeScrollMetrics(value, platform, viewportHeight));
+				},
+				fail: () => resolve(null)
+			}).exec();
+		} catch {
+			resolve(null);
+		}
+	});
+}
+var lynxKeyboardAvoidingNativeDriver = {
+	measure: measureNode,
+	async resolveKeyboardOcclusion(state) {
+		"background only";
+		const systemInfo = getSystemInfo();
+		if (!systemInfo || !state.visible) return null;
+		const rootRect = systemInfo.platform === "Android" ? await measureRoot() : null;
+		const topInScreenPx = resolveKeyboardOcclusionTop(state, systemInfo.platform, systemInfo.screenHeight, rootRect);
+		return topInScreenPx === null ? null : {
+			visible: true,
+			topInScreenPx
+		};
+	},
+	setSpacerHeight(node, height) {
+		"background only";
+		node.setNativeProps({ height: `${normalizeNonNegative(height)}px` }).exec();
+	},
+	waitForLayout() {
+		"background only";
+		return new Promise((resolve) => {
+			requestAnimationFrame(() => resolve());
+		});
+	},
+	async getScrollMetrics(node, viewportHeight) {
+		"background only";
+		const systemInfo = getSystemInfo();
+		if (!systemInfo) return null;
+		return getScrollMetrics(node, systemInfo.platform, viewportHeight);
+	},
+	scrollTo(node, offset, smooth) {
+		"background only";
+		node.invoke({
+			method: "scrollTo",
+			params: {
+				offset: normalizeNonNegative(offset),
+				smooth
+			}
+		}).exec();
+	}
+};
+//#endregion
+export { lynxKeyboardAvoidingNativeDriver };

package/lib/components/ProgressCircle/ProgressCircle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProgressCircle.d.ts","sourceRoot":"","sources":["../../../src/components/ProgressCircle/ProgressCircle.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,gBAAgB,CAAC;AAa7C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,KAAK,EAAE,sBAAsB,EAAe,MAAM,aAAa,CAAC;AA2GvE,MAAM,WAAW,uBACf,SAAQ,0BAA0B,EAChC,sBAAsB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,SAAS,GAAG,uBAAuB,CAAC;AAIhD;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,yFA8B7B,CAAC;AAIH,eAAO,MAAM,mBAAmB;;;CAQ/B,CAAC"}
+{"version":3,"file":"ProgressCircle.d.ts","sourceRoot":"","sources":["../../../src/components/ProgressCircle/ProgressCircle.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,gBAAgB,CAAC;AAa7C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,KAAK,EAAE,sBAAsB,EAAe,MAAM,aAAa,CAAC;AA2IvE,MAAM,WAAW,uBACf,SAAQ,0BAA0B,EAChC,sBAAsB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,SAAS,GAAG,uBAAuB,CAAC;AAIhD;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,yFA8B7B,CAAC;AAIH,eAAO,MAAM,mBAAmB;;;CAQ/B,CAAC"}