beez-ui 0.6.2 → 0.8.0

package/dist/lib/browser-navigation.d.ts

@@ -0,0 +1,21 @@
+/** Browser navigation helpers: full navigations and address-bar updates without history entries. */
+export declare function reloadCurrentPage(): void;
+export declare function navigateToUrl(url: string): void;
+/**
+ * Sets (or removes, with `null`) query parameters of the current URL in a
+ * single `history.replaceState`, which the Next.js router tracks, so the
+ * address bar reflects UI state without a navigation or a history entry.
+ * Parameters not listed keep their current value, as do the path and hash.
+ *
+ * @param searchParams - New value per query parameter name, or null to remove it.
+ */
+export declare function replaceCurrentUrlSearchParams(searchParams: Readonly<Record<string, string | null>>): void;
+/**
+ * Replaces every value of one repeatable query parameter of the current URL
+ * (an empty list removes it) through `history.replaceState`, like
+ * {@link replaceCurrentUrlSearchParams}.
+ *
+ * @param name - Query parameter name.
+ * @param values - New values, in order.
+ */
+export declare function replaceCurrentUrlSearchParamValues(name: string, values: readonly string[]): void;

package/dist/lib/browser-navigation.js

@@ -0,0 +1,42 @@
+/** Browser navigation helpers: full navigations and address-bar updates without history entries. */
+export function reloadCurrentPage() {
+	window.location.reload();
+}
+export function navigateToUrl(url) {
+	window.location.href = url;
+}
+/**
+* Sets (or removes, with `null`) query parameters of the current URL in a
+* single `history.replaceState`, which the Next.js router tracks, so the
+* address bar reflects UI state without a navigation or a history entry.
+* Parameters not listed keep their current value, as do the path and hash.
+*
+* @param searchParams - New value per query parameter name, or null to remove it.
+*/
+export function replaceCurrentUrlSearchParams(searchParams) {
+	const url = new URL(window.location.href);
+	for (const [name, value] of Object.entries(searchParams)) {
+		if (value === null) {
+			url.searchParams.delete(name);
+		} else {
+			url.searchParams.set(name, value);
+		}
+	}
+	window.history.replaceState(null, "", url.pathname + url.search + url.hash);
+}
+/**
+* Replaces every value of one repeatable query parameter of the current URL
+* (an empty list removes it) through `history.replaceState`, like
+* {@link replaceCurrentUrlSearchParams}.
+*
+* @param name - Query parameter name.
+* @param values - New values, in order.
+*/
+export function replaceCurrentUrlSearchParamValues(name, values) {
+	const url = new URL(window.location.href);
+	url.searchParams.delete(name);
+	for (const value of values) {
+		url.searchParams.append(name, value);
+	}
+	window.history.replaceState(null, "", url.pathname + url.search + url.hash);
+}

package/dist/lib/column-filter-value.d.ts

@@ -0,0 +1,12 @@
+/** Normalizes text for accent- and case-insensitive comparisons. */
+export declare function normalizeFilterToken(value: string): string;
+/**
+ * Evalúa el valor de una celda contra un filtro de columna de la barra de filtros.
+ * Entiende los valores estructurados (`numberRange`, `enum`, `presence`, `yearMonthRange`)
+ * y, para texto plano, busca coincidencias parciales sin distinguir acentos ni mayúsculas.
+ * Una celda sin valor comparable no cumple los rangos; un filtro vacío deja pasar la fila.
+ * @param cellValue - Valor de la celda tal como lo devuelve el accessor de la columna.
+ * @param filterValue - Valor activo del filtro de esa columna.
+ * @returns `true` cuando la fila debe mostrarse.
+ */
+export declare function matchesColumnFilterValue(cellValue: unknown, filterValue: unknown): boolean;

package/dist/lib/column-filter-value.js

@@ -0,0 +1,52 @@
+import { matchesAdvancedYearMonthRangeFilter } from "./year-month-filter.js";
+const DIACRITICS_PATTERN = /[̀-ͯ]/g;
+/** Normalizes text for accent- and case-insensitive comparisons. */
+export function normalizeFilterToken(value) {
+	return value.normalize("NFD").replace(DIACRITICS_PATTERN, "").toLocaleLowerCase().trim();
+}
+/** Distinguishes the grammar's structured values from plain text written by the search input. */
+function isColumnFilterValue(value) {
+	return typeof value === "object" && value !== null && typeof value.kind === "string";
+}
+/** Reads numbers and numeric strings; anything else has no comparable value. */
+function toFiniteNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+}
+/** Treats `null`, `undefined`, blank strings and empty lists as a missing value. */
+function isMissingValue(value) {
+	if (value == null) return true;
+	if (typeof value === "string") return value.trim() === "";
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+}
+/**
+* Evalúa el valor de una celda contra un filtro de columna de la barra de filtros.
+* Entiende los valores estructurados (`numberRange`, `enum`, `presence`, `yearMonthRange`)
+* y, para texto plano, busca coincidencias parciales sin distinguir acentos ni mayúsculas.
+* Una celda sin valor comparable no cumple los rangos; un filtro vacío deja pasar la fila.
+* @param cellValue - Valor de la celda tal como lo devuelve el accessor de la columna.
+* @param filterValue - Valor activo del filtro de esa columna.
+* @returns `true` cuando la fila debe mostrarse.
+*/
+export function matchesColumnFilterValue(cellValue, filterValue) {
+	if (!isColumnFilterValue(filterValue)) {
+		const query = normalizeFilterToken(String(filterValue ?? ""));
+		return query === "" || normalizeFilterToken(String(cellValue ?? "")).includes(query);
+	}
+	switch (filterValue.kind) {
+		case "numberRange": {
+			const value = toFiniteNumber(cellValue);
+			if (value == null) return false;
+			if (filterValue.min != null && value < filterValue.min) return false;
+			return filterValue.max == null || value <= filterValue.max;
+		}
+		case "enum": return Array.isArray(cellValue) ? cellValue.some((item) => String(item) === filterValue.value) : String(cellValue ?? "") === filterValue.value;
+		case "presence": return filterValue.value === "hasValue" ? !isMissingValue(cellValue) : isMissingValue(cellValue);
+		case "yearMonthRange": return matchesAdvancedYearMonthRangeFilter(filterValue, toFiniteNumber(cellValue));
+	}
+}

package/dist/lib/file-acceptance.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Validates picked or dropped files against an `accept` list and a size limit, mirroring the
+ * native `<input accept>` syntax. Files without a MIME type (common on some Android pickers and
+ * drag sources) fall back to their extension.
+ */
+/** File metadata the checks need; a `File` satisfies it. */
+export interface AcceptableFile {
+    name: string;
+    type: string;
+    size: number;
+}
+/**
+ * Extracts the lowercase extension from a file name.
+ * @param fileName - The file name.
+ * @returns The extension with its leading dot, or null when there is none.
+ */
+export declare function getFileExtension(fileName: string): string | null;
+/**
+ * Tells whether a file matches an `accept` list such as `"image/*,.pdf"`.
+ * @param file - File to check.
+ * @param accept - Comma-separated extensions, exact MIME types or `type/*` wildcards; empty accepts all.
+ * @returns Whether the file is accepted.
+ */
+export declare function isFileTypeAccepted(file: AcceptableFile, accept?: string): boolean;
+export interface ClassifyFilesOptions {
+    accept?: string;
+    /** Maximum size in bytes; checked before the type. */
+    maxSize?: number;
+    /** When false, only the first file is considered. */
+    allowsMultiple?: boolean;
+}
+export interface ClassifiedFiles<TFile extends AcceptableFile> {
+    accepted: TFile[];
+    unaccepted: TFile[];
+    oversized: TFile[];
+}
+/**
+ * Splits files into accepted, wrong-type and oversized groups.
+ * @param files - Picked or dropped files.
+ * @param options - Accept list, size limit and multiplicity.
+ * @returns The three groups, preserving input order.
+ */
+export declare function classifyFiles<TFile extends AcceptableFile>(files: readonly TFile[], { accept, maxSize, allowsMultiple }?: ClassifyFilesOptions): ClassifiedFiles<TFile>;

package/dist/lib/file-acceptance.js

@@ -0,0 +1,107 @@
+/**
+* Validates picked or dropped files against an `accept` list and a size limit, mirroring the
+* native `<input accept>` syntax. Files without a MIME type (common on some Android pickers and
+* drag sources) fall back to their extension.
+*/
+const MIME_TYPE_EXTENSION_FALLBACKS = {
+	"application/pdf": [".pdf"],
+	"audio/mpeg": [".mp3"],
+	"image/gif": [".gif"],
+	"image/heic": [".heic"],
+	"image/heif": [".heif"],
+	"image/jpeg": [".jpg", ".jpeg"],
+	"image/png": [".png"],
+	"image/webp": [".webp"],
+	"text/plain": [".txt"],
+	"video/mp4": [".mp4"]
+};
+const WILDCARD_MIME_PREFIX_EXTENSION_FALLBACKS = {
+	audio: [
+		".aac",
+		".flac",
+		".m4a",
+		".mp3",
+		".ogg",
+		".wav"
+	],
+	image: [
+		".avif",
+		".bmp",
+		".gif",
+		".heic",
+		".heif",
+		".jpeg",
+		".jpg",
+		".png",
+		".svg",
+		".webp"
+	],
+	text: [
+		".csv",
+		".md",
+		".txt"
+	],
+	video: [
+		".avi",
+		".m4v",
+		".mov",
+		".mp4",
+		".mkv",
+		".webm"
+	]
+};
+const ACCEPT_LIST_SEPARATOR = ",";
+const EXTENSION_PREFIX = ".";
+const MIME_WILDCARD_SUFFIX = "/*";
+const MIME_TYPE_SEPARATOR = "/";
+/**
+* Extracts the lowercase extension from a file name.
+* @param fileName - The file name.
+* @returns The extension with its leading dot, or null when there is none.
+*/
+export function getFileExtension(fileName) {
+	const fileNameParts = fileName.split(EXTENSION_PREFIX);
+	const extension = fileNameParts.length > 1 ? fileNameParts.pop() : null;
+	return extension ? `${EXTENSION_PREFIX}${extension.toLowerCase()}` : null;
+}
+/**
+* Tells whether a file matches an `accept` list such as `"image/*,.pdf"`.
+* @param file - File to check.
+* @param accept - Comma-separated extensions, exact MIME types or `type/*` wildcards; empty accepts all.
+* @returns Whether the file is accepted.
+*/
+export function isFileTypeAccepted(file, accept) {
+	if (!accept) return true;
+	const fileExtension = getFileExtension(file.name);
+	const normalizedFileType = file.type.toLowerCase();
+	const hasMimeType = normalizedFileType.length > 0;
+	const extensionMatches = (candidateExtensions) => Boolean(fileExtension && candidateExtensions?.includes(fileExtension));
+	return accept.split(ACCEPT_LIST_SEPARATOR).map((acceptedType) => acceptedType.trim().toLowerCase()).filter(Boolean).some((acceptedType) => {
+		if (acceptedType.startsWith(EXTENSION_PREFIX)) return fileExtension === acceptedType;
+		if (acceptedType.endsWith(MIME_WILDCARD_SUFFIX)) {
+			const typePrefix = acceptedType.split(MIME_TYPE_SEPARATOR)[0];
+			return hasMimeType ? normalizedFileType.startsWith(`${typePrefix}${MIME_TYPE_SEPARATOR}`) : extensionMatches(WILDCARD_MIME_PREFIX_EXTENSION_FALLBACKS[typePrefix]);
+		}
+		return hasMimeType && normalizedFileType === acceptedType || extensionMatches(MIME_TYPE_EXTENSION_FALLBACKS[acceptedType]);
+	});
+}
+/**
+* Splits files into accepted, wrong-type and oversized groups.
+* @param files - Picked or dropped files.
+* @param options - Accept list, size limit and multiplicity.
+* @returns The three groups, preserving input order.
+*/
+export function classifyFiles(files, { accept, maxSize, allowsMultiple = true } = {}) {
+	const classifiedFiles = {
+		accepted: [],
+		unaccepted: [],
+		oversized: []
+	};
+	const filesToProcess = allowsMultiple ? files : files.slice(0, 1);
+	for (const file of filesToProcess) {
+		if (maxSize !== undefined && file.size > maxSize) classifiedFiles.oversized.push(file);
+		else if (isFileTypeAccepted(file, accept)) classifiedFiles.accepted.push(file);
+		else classifiedFiles.unaccepted.push(file);
+	}
+	return classifiedFiles;
+}

package/dist/lib/format-file-size.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pure file-size formatting helper shared by attachment and upload UIs. Framework-safe:
+ * no React, no platform APIs beyond `Intl`, so it runs on the server and the client alike.
+ */
+export interface FormatFileSizeOptions {
+    /** BCP 47 locale used for the decimal separator. Defaults to `es-AR`. */
+    locale?: string;
+}
+/**
+ * Formats a byte count as a short human-readable size, e.g. `12,3 MB`, `850 KB`, `25 MB`.
+ *
+ * @param bytes - Raw size in bytes. Non-finite or negative values render as `0 B`.
+ * @param options - Optional locale for the number format.
+ * @returns The formatted size with its unit, separated by a space.
+ */
+export declare function formatFileSize(bytes: number, { locale }?: FormatFileSizeOptions): string;

package/dist/lib/format-file-size.js

@@ -0,0 +1,34 @@
+/**
+* Pure file-size formatting helper shared by attachment and upload UIs. Framework-safe:
+* no React, no platform APIs beyond `Intl`, so it runs on the server and the client alike.
+*/
+const BYTES_PER_UNIT_STEP = 1024;
+const FILE_SIZE_UNIT_LABELS = [
+	"B",
+	"KB",
+	"MB",
+	"GB",
+	"TB"
+];
+/** Spanish (Argentina) keeps the comma decimal separator of the original product copy. */
+const DEFAULT_FILE_SIZE_LOCALE = "es-AR";
+const SUB_UNIT_FRACTION_DIGITS = 0;
+const SCALED_UNIT_FRACTION_DIGITS = 1;
+/**
+* Formats a byte count as a short human-readable size, e.g. `12,3 MB`, `850 KB`, `25 MB`.
+*
+* @param bytes - Raw size in bytes. Non-finite or negative values render as `0 B`.
+* @param options - Optional locale for the number format.
+* @returns The formatted size with its unit, separated by a space.
+*/
+export function formatFileSize(bytes, { locale = DEFAULT_FILE_SIZE_LOCALE } = {}) {
+	const safeBytes = Number.isFinite(bytes) && bytes > 0 ? bytes : 0;
+	let scaledValue = safeBytes;
+	let unitIndex = 0;
+	while (scaledValue >= BYTES_PER_UNIT_STEP && unitIndex < FILE_SIZE_UNIT_LABELS.length - 1) {
+		scaledValue /= BYTES_PER_UNIT_STEP;
+		unitIndex += 1;
+	}
+	const formattedValue = new Intl.NumberFormat(locale, { maximumFractionDigits: unitIndex === 0 ? SUB_UNIT_FRACTION_DIGITS : SCALED_UNIT_FRACTION_DIGITS }).format(scaledValue);
+	return `${formattedValue} ${FILE_SIZE_UNIT_LABELS[unitIndex]}`;
+}

package/dist/lib/fuzzy-search.d.ts

@@ -0,0 +1,17 @@
+/** Ranks and highlights fuzzy text matches, ignoring case and diacritics, for pickers and search lists. */
+import type { ReactNode } from "react";
+export interface FuzzyMatchRank {
+    contiguousPairCount: number;
+    gapCount: number;
+    longestRun: number;
+    matchedChars: number;
+    maxGap: number;
+    span: number;
+    startIndex: number;
+}
+export declare function compareFuzzyMatchRank(leftRank: FuzzyMatchRank, rightRank: FuzzyMatchRank): number;
+export declare function normalizeSearchValue(value: string): string;
+export declare function getExactMatchIndices(value: string, query: string): number[] | null;
+export declare function getFuzzyMatchIndices(value: string, query: string): number[] | null;
+export declare function getFuzzyMatchRank(value: string, query: string): FuzzyMatchRank | null;
+export declare function renderHighlightedText(value: string, matchedIndices: number[], highlightClassName: string, keyPrefix: string): ReactNode;

package/dist/lib/fuzzy-search.js

@@ -0,0 +1,183 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const DIACRITICS_PATTERN = /[\u0300-\u036f]/g;
+export function compareFuzzyMatchRank(leftRank, rightRank) {
+	if (leftRank.longestRun !== rightRank.longestRun) {
+		return rightRank.longestRun - leftRank.longestRun;
+	}
+	if (leftRank.contiguousPairCount !== rightRank.contiguousPairCount) {
+		return rightRank.contiguousPairCount - leftRank.contiguousPairCount;
+	}
+	if (leftRank.gapCount !== rightRank.gapCount) {
+		return leftRank.gapCount - rightRank.gapCount;
+	}
+	if (leftRank.maxGap !== rightRank.maxGap) {
+		return leftRank.maxGap - rightRank.maxGap;
+	}
+	if (leftRank.span !== rightRank.span) {
+		return leftRank.span - rightRank.span;
+	}
+	if (leftRank.startIndex !== rightRank.startIndex) {
+		return leftRank.startIndex - rightRank.startIndex;
+	}
+	return 0;
+}
+export function normalizeSearchValue(value) {
+	return value.normalize("NFD").replace(DIACRITICS_PATTERN, "").toLocaleLowerCase();
+}
+function getSearchCharsWithSourceIndices(value) {
+	const chars = [];
+	for (let index = 0; index < value.length; index += 1) {
+		const normalizedChar = normalizeSearchValue(value[index]);
+		if (!normalizedChar) {
+			continue;
+		}
+		for (const char of normalizedChar) {
+			chars.push({
+				char,
+				sourceIndex: index
+			});
+		}
+	}
+	return chars;
+}
+export function getExactMatchIndices(value, query) {
+	const normalizedQuery = normalizeSearchValue(query).trim();
+	if (!normalizedQuery) {
+		return [];
+	}
+	const valueChars = getSearchCharsWithSourceIndices(value);
+	const queryChars = Array.from(normalizedQuery);
+	if (queryChars.length > valueChars.length) {
+		return null;
+	}
+	for (let valueIndex = 0; valueIndex <= valueChars.length - queryChars.length; valueIndex += 1) {
+		let isExactMatch = true;
+		for (let queryIndex = 0; queryIndex < queryChars.length; queryIndex += 1) {
+			if (valueChars[valueIndex + queryIndex].char !== queryChars[queryIndex]) {
+				isExactMatch = false;
+				break;
+			}
+		}
+		if (!isExactMatch) {
+			continue;
+		}
+		const matchStartSourceIndex = valueChars[valueIndex].sourceIndex;
+		const matchEndSourceIndex = valueChars[valueIndex + queryChars.length - 1].sourceIndex;
+		return Array.from({ length: matchEndSourceIndex - matchStartSourceIndex + 1 }, (_, index) => matchStartSourceIndex + index);
+	}
+	return null;
+}
+export function getFuzzyMatchIndices(value, query) {
+	const normalizedQuery = normalizeSearchValue(query).trim();
+	if (!normalizedQuery) {
+		return [];
+	}
+	const valueChars = getSearchCharsWithSourceIndices(value);
+	const queryChars = Array.from(normalizedQuery);
+	const matchedIndices = [];
+	let valueCursor = 0;
+	for (const queryChar of queryChars) {
+		let foundAt = -1;
+		for (let index = valueCursor; index < valueChars.length; index += 1) {
+			if (valueChars[index].char === queryChar) {
+				foundAt = index;
+				break;
+			}
+		}
+		if (foundAt === -1) {
+			return null;
+		}
+		matchedIndices.push(valueChars[foundAt].sourceIndex);
+		valueCursor = foundAt + 1;
+	}
+	return Array.from(new Set(matchedIndices));
+}
+export function getFuzzyMatchRank(value, query) {
+	const normalizedQuery = normalizeSearchValue(query).trim();
+	if (!normalizedQuery) {
+		return null;
+	}
+	const valueChars = getSearchCharsWithSourceIndices(value);
+	const queryChars = Array.from(normalizedQuery);
+	const matchedSourceIndices = [];
+	let valueCursor = 0;
+	for (const queryChar of queryChars) {
+		let foundAt = -1;
+		for (let index = valueCursor; index < valueChars.length; index += 1) {
+			if (valueChars[index].char === queryChar) {
+				foundAt = index;
+				break;
+			}
+		}
+		if (foundAt === -1) {
+			return null;
+		}
+		matchedSourceIndices.push(valueChars[foundAt].sourceIndex);
+		valueCursor = foundAt + 1;
+	}
+	const startIndex = matchedSourceIndices[0] ?? 0;
+	const endIndex = matchedSourceIndices[matchedSourceIndices.length - 1] ?? startIndex;
+	let contiguousPairCount = 0;
+	let gapCount = 0;
+	let longestRun = matchedSourceIndices.length > 0 ? 1 : 0;
+	let maxGap = 0;
+	let currentRun = matchedSourceIndices.length > 0 ? 1 : 0;
+	for (let index = 1; index < matchedSourceIndices.length; index += 1) {
+		if (matchedSourceIndices[index] === matchedSourceIndices[index - 1] + 1) {
+			contiguousPairCount += 1;
+			currentRun += 1;
+		} else {
+			currentRun = 1;
+		}
+		if (currentRun > longestRun) {
+			longestRun = currentRun;
+		}
+		const gap = Math.max(matchedSourceIndices[index] - matchedSourceIndices[index - 1] - 1, 0);
+		gapCount += gap;
+		if (gap > maxGap) {
+			maxGap = gap;
+		}
+	}
+	return {
+		contiguousPairCount,
+		gapCount,
+		longestRun,
+		matchedChars: queryChars.length,
+		maxGap,
+		span: Math.max(endIndex - startIndex, 0),
+		startIndex
+	};
+}
+export function renderHighlightedText(value, matchedIndices, highlightClassName, keyPrefix) {
+	if (matchedIndices.length === 0) {
+		return value;
+	}
+	const matchedIndexSet = new Set(matchedIndices);
+	const highlightedParts = [];
+	let currentStart = 0;
+	let partIndex = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		if (!matchedIndexSet.has(index)) {
+			continue;
+		}
+		if (currentStart < index) {
+			highlightedParts.push(/* @__PURE__ */ _jsx("span", { children: value.slice(currentStart, index) }, `${keyPrefix}-text-${partIndex}`));
+			partIndex += 1;
+		}
+		let matchEnd = index + 1;
+		while (matchEnd < value.length && matchedIndexSet.has(matchEnd)) {
+			matchEnd += 1;
+		}
+		highlightedParts.push(/* @__PURE__ */ _jsx("mark", {
+			className: highlightClassName,
+			children: value.slice(index, matchEnd)
+		}, `${keyPrefix}-match-${partIndex}`));
+		partIndex += 1;
+		currentStart = matchEnd;
+		index = matchEnd - 1;
+	}
+	if (currentStart < value.length) {
+		highlightedParts.push(/* @__PURE__ */ _jsx("span", { children: value.slice(currentStart) }, `${keyPrefix}-text-${partIndex}`));
+	}
+	return /* @__PURE__ */ _jsx("span", { children: highlightedParts }, `${keyPrefix}-highlighted`);
+}

package/dist/lib/horizontal-swipe.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure classification of a pointer drag into a horizontal swipe. Kept apart
+ * from the DOM so thresholds are unit-testable and shared by any pager.
+ */
+export declare const HORIZONTAL_SWIPE_DIRECTION: {
+    readonly next: "next";
+    readonly previous: "previous";
+};
+export type HorizontalSwipeDirection = (typeof HORIZONTAL_SWIPE_DIRECTION)[keyof typeof HORIZONTAL_SWIPE_DIRECTION];
+export type HorizontalSwipeGesture = {
+    deltaX: number;
+    deltaY: number;
+    durationMs: number;
+};
+/**
+ * Decides whether a drag is a deliberate horizontal swipe. A leftward swipe
+ * moves to the next page and a rightward one to the previous page, like
+ * turning a calendar page.
+ *
+ * @param gesture - Pointer travel and duration.
+ * @returns The swipe direction, or null when the drag is not a swipe.
+ */
+export declare function resolveHorizontalSwipe(gesture: HorizontalSwipeGesture): HorizontalSwipeDirection | null;

package/dist/lib/horizontal-swipe.js

@@ -0,0 +1,29 @@
+/**
+* Pure classification of a pointer drag into a horizontal swipe. Kept apart
+* from the DOM so thresholds are unit-testable and shared by any pager.
+*/
+export const HORIZONTAL_SWIPE_DIRECTION = {
+	next: "next",
+	previous: "previous"
+};
+/** Minimum horizontal travel, in CSS pixels, to count as a swipe. */
+const SWIPE_MIN_DISTANCE_PX = 60;
+/** Horizontal travel must dominate vertical travel by this ratio. */
+const SWIPE_HORIZONTAL_DOMINANCE_RATIO = 1.5;
+/** Slower drags read as reading/scrolling, not as a page flip. */
+const SWIPE_MAX_DURATION_MS = 800;
+/**
+* Decides whether a drag is a deliberate horizontal swipe. A leftward swipe
+* moves to the next page and a rightward one to the previous page, like
+* turning a calendar page.
+*
+* @param gesture - Pointer travel and duration.
+* @returns The swipe direction, or null when the drag is not a swipe.
+*/
+export function resolveHorizontalSwipe(gesture) {
+	const horizontalDistance = Math.abs(gesture.deltaX);
+	if (horizontalDistance < SWIPE_MIN_DISTANCE_PX || horizontalDistance < Math.abs(gesture.deltaY) * SWIPE_HORIZONTAL_DOMINANCE_RATIO || gesture.durationMs > SWIPE_MAX_DURATION_MS) {
+		return null;
+	}
+	return gesture.deltaX < 0 ? HORIZONTAL_SWIPE_DIRECTION.next : HORIZONTAL_SWIPE_DIRECTION.previous;
+}

package/dist/lib/in-app-browser.d.ts

@@ -0,0 +1,35 @@
+/** Detects in-app browsers and builds deep links that reopen a URL in the default browser. */
+export type InAppBrowserDetectionResult = {
+    isInAppBrowser: boolean;
+    isIos: boolean;
+    isAndroid: boolean;
+    isMercadoPago: boolean;
+};
+/**
+ * Classifies a user agent: in-app browsers (social, messaging and payment apps, iOS web views)
+ * often block sign-in popups or lose sessions, so callers can offer to continue elsewhere.
+ * Safe on the server: pass the request `User-Agent` header.
+ *
+ * @param userAgent - User agent string, or nothing when unknown.
+ * @returns Whether it is an in-app browser and which platform it runs on.
+ */
+export declare function detectInAppBrowser(userAgent: string | null | undefined): InAppBrowserDetectionResult;
+export declare const EXTERNAL_BROWSER_PLATFORM: {
+    readonly android: "android";
+    readonly ios: "ios";
+};
+export type ExternalBrowserPlatform = (typeof EXTERNAL_BROWSER_PLATFORM)[keyof typeof EXTERNAL_BROWSER_PLATFORM];
+type BuildExternalBrowserUrlInput = {
+    platform: ExternalBrowserPlatform;
+    targetHttpsUrl: string;
+};
+/**
+ * Builds a deep link that asks the OS to open the given https URL in the
+ * user's default external browser instead of the in-app browser.
+ *
+ * @param input - Target URL and detected platform.
+ * @returns A deep-link URL for iOS Safari or Android Chrome. Returns null when
+ *          the target URL does not use the https scheme.
+ */
+export declare function buildExternalBrowserUrl({ platform, targetHttpsUrl, }: BuildExternalBrowserUrlInput): string | null;
+export {};