@hot-updater/plugin-insights 1.0.0-rc.20

package/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2023 Sungyu Kang 
+
+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.
+
+---
+
+ADDITIONAL DISCLAIMER
+
+The authors of this software shall not be held responsible for any legal issues,
+regulatory violations, policy violations, or disputes arising from the use,
+distribution, or integration of this software.
+
+Users are solely responsible for ensuring compliance with all applicable laws,
+regulations, and third-party policies (including but not limited to app store
+policies).

package/README.md

@@ -0,0 +1,24 @@
+# @hot-updater/plugin-insights
+
+Hot Updater's Insights plugin. The server plugin records launches, downloads,
+and update failures and serves them to the Console and the CLI; the client
+plugin reports them from the app.
+
+You don't install it on its own. `@hot-updater/server` and
+`@hot-updater/react-native` depend on it and re-export it:
+
+```ts
+// The server definition
+import { insights } from "@hot-updater/server/plugins/insights";
+
+// The app
+import { insights } from "@hot-updater/react-native/plugins/insights";
+```
+
+| Entry       | Re-exported as                                  |
+| ----------- | ----------------------------------------------- |
+| `./server`  | `@hot-updater/server/plugins/insights`          |
+| `./client`  | `@hot-updater/react-native/plugins/insights`    |
+| `./testing` | `@hot-updater/server/plugins/insights/testing`  |
+
+See [Insights](https://hot-updater.dev/docs/guides/insights).

package/client/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@hot-updater/plugin-insights/client",
+  "private": true,
+  "main": "../dist/client/index.cjs",
+  "module": "../dist/client/index.mjs",
+  "types": "../dist/client/index.d.cts"
+}

package/dist/client/eventId.cjs

@@ -0,0 +1,181 @@
+//#region src/client/eventId.ts
+const formatUUIDv7 = (bytes, timestamp) => {
+	let time = timestamp;
+	for (let index = 5; index >= 0; index -= 1) {
+		bytes[index] = time % 256;
+		time = Math.floor(time / 256);
+	}
+	bytes[6] = 112 | bytes[6] & 15;
+	bytes[8] = 128 | bytes[8] & 63;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+/**
+* Creates an RFC 9562 UUIDv7: a 48-bit millisecond timestamp, then random bits.
+*
+* `createUUIDv7` from `@hot-updater/plugin-core` calls `crypto.getRandomValues`
+* unconditionally, but React Native has no Web Crypto unless the app installs a
+* polyfill. An Insights event ID only has to tell one event from another so a
+* retried POST is counted once, so `Math.random` is enough without one.
+*/
+const createUUIDv7 = () => {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	const { crypto } = globalThis;
+	if (typeof crypto?.getRandomValues === "function") crypto.getRandomValues(bytes);
+	else for (let index = 0; index < bytes.length; index += 1) bytes[index] = Math.floor(Math.random() * 256);
+	return formatUUIDv7(bytes, Date.now());
+};
+const SHA256_K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+const encodeUtf8 = (value) => {
+	const bytes = [];
+	for (const character of value) {
+		const code = character.codePointAt(0);
+		if (code < 128) bytes.push(code);
+		else if (code < 2048) bytes.push(192 | code >> 6, 128 | code & 63);
+		else if (code < 65536) bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+		else bytes.push(240 | code >> 18, 128 | code >> 12 & 63, 128 | code >> 6 & 63, 128 | code & 63);
+	}
+	return bytes;
+};
+/** SHA-256 of a string's UTF-8 bytes, since React Native has no Web Crypto. */
+const sha256 = (value) => {
+	const bytes = encodeUtf8(value);
+	const bitLength = bytes.length * 8;
+	bytes.push(128);
+	while (bytes.length % 64 !== 56) bytes.push(0);
+	for (let shift = 56; shift >= 0; shift -= 8) bytes.push(shift >= 32 ? Math.floor(bitLength / 2 ** shift) & 255 : bitLength >>> shift & 255);
+	const hash = [
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	];
+	const words = Array.from({ length: 64 }, () => 0);
+	const rotate = (word, bits) => word >>> bits | word << 32 - bits;
+	for (let offset = 0; offset < bytes.length; offset += 64) {
+		for (let index = 0; index < 16; index += 1) {
+			const at = offset + index * 4;
+			words[index] = bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3];
+		}
+		for (let index = 16; index < 64; index += 1) {
+			const low = words[index - 15];
+			const high = words[index - 2];
+			const s0 = rotate(low, 7) ^ rotate(low, 18) ^ low >>> 3;
+			const s1 = rotate(high, 17) ^ rotate(high, 19) ^ high >>> 10;
+			words[index] = words[index - 16] + s0 + words[index - 7] + s1 | 0;
+		}
+		let [a, b, c, d, e, f, g, h] = hash;
+		for (let index = 0; index < 64; index += 1) {
+			const s1 = rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25);
+			const choose = e & f ^ ~e & g;
+			const temp1 = h + s1 + choose + SHA256_K[index] + words[index] | 0;
+			const temp2 = (rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + temp1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = temp1 + temp2 | 0;
+		}
+		const results = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f,
+			g,
+			h
+		];
+		for (let index = 0; index < 8; index += 1) hash[index] = hash[index] + results[index] | 0;
+	}
+	const digest = /* @__PURE__ */ new Uint8Array(32);
+	hash.forEach((word, index) => {
+		digest[index * 4] = word >>> 24 & 255;
+		digest[index * 4 + 1] = word >>> 16 & 255;
+		digest[index * 4 + 2] = word >>> 8 & 255;
+		digest[index * 4 + 3] = word & 255;
+	});
+	return digest;
+};
+/**
+* A UUIDv7 derived from a key: its time field is `timestamp` and its random
+* bits are the key's SHA-256, so the same key and time always give the same
+* id, and a server that stores reports by id counts it once.
+*/
+const createKeyedUUIDv7 = (key, timestamp) => formatUUIDv7(sha256(key).slice(0, 16), timestamp);
+//#endregion
+exports.createKeyedUUIDv7 = createKeyedUUIDv7;
+exports.createUUIDv7 = createUUIDv7;
+exports.sha256 = sha256;

package/dist/client/eventId.mjs

@@ -0,0 +1,179 @@
+//#region src/client/eventId.ts
+const formatUUIDv7 = (bytes, timestamp) => {
+	let time = timestamp;
+	for (let index = 5; index >= 0; index -= 1) {
+		bytes[index] = time % 256;
+		time = Math.floor(time / 256);
+	}
+	bytes[6] = 112 | bytes[6] & 15;
+	bytes[8] = 128 | bytes[8] & 63;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+/**
+* Creates an RFC 9562 UUIDv7: a 48-bit millisecond timestamp, then random bits.
+*
+* `createUUIDv7` from `@hot-updater/plugin-core` calls `crypto.getRandomValues`
+* unconditionally, but React Native has no Web Crypto unless the app installs a
+* polyfill. An Insights event ID only has to tell one event from another so a
+* retried POST is counted once, so `Math.random` is enough without one.
+*/
+const createUUIDv7 = () => {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	const { crypto } = globalThis;
+	if (typeof crypto?.getRandomValues === "function") crypto.getRandomValues(bytes);
+	else for (let index = 0; index < bytes.length; index += 1) bytes[index] = Math.floor(Math.random() * 256);
+	return formatUUIDv7(bytes, Date.now());
+};
+const SHA256_K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+const encodeUtf8 = (value) => {
+	const bytes = [];
+	for (const character of value) {
+		const code = character.codePointAt(0);
+		if (code < 128) bytes.push(code);
+		else if (code < 2048) bytes.push(192 | code >> 6, 128 | code & 63);
+		else if (code < 65536) bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+		else bytes.push(240 | code >> 18, 128 | code >> 12 & 63, 128 | code >> 6 & 63, 128 | code & 63);
+	}
+	return bytes;
+};
+/** SHA-256 of a string's UTF-8 bytes, since React Native has no Web Crypto. */
+const sha256 = (value) => {
+	const bytes = encodeUtf8(value);
+	const bitLength = bytes.length * 8;
+	bytes.push(128);
+	while (bytes.length % 64 !== 56) bytes.push(0);
+	for (let shift = 56; shift >= 0; shift -= 8) bytes.push(shift >= 32 ? Math.floor(bitLength / 2 ** shift) & 255 : bitLength >>> shift & 255);
+	const hash = [
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	];
+	const words = Array.from({ length: 64 }, () => 0);
+	const rotate = (word, bits) => word >>> bits | word << 32 - bits;
+	for (let offset = 0; offset < bytes.length; offset += 64) {
+		for (let index = 0; index < 16; index += 1) {
+			const at = offset + index * 4;
+			words[index] = bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3];
+		}
+		for (let index = 16; index < 64; index += 1) {
+			const low = words[index - 15];
+			const high = words[index - 2];
+			const s0 = rotate(low, 7) ^ rotate(low, 18) ^ low >>> 3;
+			const s1 = rotate(high, 17) ^ rotate(high, 19) ^ high >>> 10;
+			words[index] = words[index - 16] + s0 + words[index - 7] + s1 | 0;
+		}
+		let [a, b, c, d, e, f, g, h] = hash;
+		for (let index = 0; index < 64; index += 1) {
+			const s1 = rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25);
+			const choose = e & f ^ ~e & g;
+			const temp1 = h + s1 + choose + SHA256_K[index] + words[index] | 0;
+			const temp2 = (rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + temp1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = temp1 + temp2 | 0;
+		}
+		const results = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f,
+			g,
+			h
+		];
+		for (let index = 0; index < 8; index += 1) hash[index] = hash[index] + results[index] | 0;
+	}
+	const digest = /* @__PURE__ */ new Uint8Array(32);
+	hash.forEach((word, index) => {
+		digest[index * 4] = word >>> 24 & 255;
+		digest[index * 4 + 1] = word >>> 16 & 255;
+		digest[index * 4 + 2] = word >>> 8 & 255;
+		digest[index * 4 + 3] = word & 255;
+	});
+	return digest;
+};
+/**
+* A UUIDv7 derived from a key: its time field is `timestamp` and its random
+* bits are the key's SHA-256, so the same key and time always give the same
+* id, and a server that stores reports by id counts it once.
+*/
+const createKeyedUUIDv7 = (key, timestamp) => formatUUIDv7(sha256(key).slice(0, 16), timestamp);
+//#endregion
+export { createKeyedUUIDv7, createUUIDv7, sha256 };

package/dist/client/index.cjs

@@ -0,0 +1,234 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_eventId = require("./eventId.cjs");
+const require_sender = require("./sender.cjs");
+const require_state = require("./state.cjs");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/client/index.ts
+const normalizeUserId = (user) => {
+	if (user === null) return null;
+	const userId = String(user.userId).trim();
+	return userId.length === 0 ? null : userId;
+};
+/**
+* Reports update adoption to a server that runs the `insights()` server
+* plugin: launches (at most once a UTC day while nothing changes), downloads,
+* applies, recoveries, and update failures. After the server answers that
+* Insights is off, the plugin sends nothing for 24 hours, and for the rest
+* of that runtime.
+*
+* @example
+* ```ts
+* import { HotUpdater } from "@hot-updater/react-native";
+* import { insights } from "@hot-updater/react-native/plugins/insights";
+*
+* const analytics = insights();
+* HotUpdater.init({ baseURL, plugins: [analytics] });
+* analytics.setUser({ userId: "user-123" });
+* ```
+*/
+const insights = (options = {}) => {
+	let context = null;
+	let state = null;
+	/** A user set before setup, applied once the plugin has storage. */
+	let pendingUser = null;
+	/** A download in this runtime: a later no-change report would hide it. */
+	let didDownload = false;
+	let lastDownloadedSelection = null;
+	const pending = /* @__PURE__ */ new Map();
+	let send = null;
+	const createEvent = (movement, eventId) => {
+		if (context === null || state === null) return null;
+		const appVersion = context.appVersion;
+		if (appVersion === null) {
+			console.warn(`[HotUpdater] Insights needs the native app version; the ${movement.type} event was not sent.`);
+			return null;
+		}
+		const now = context.now();
+		const installId = context.installId;
+		const userId = state.readUserId();
+		const body = {
+			...movement,
+			eventId: eventId?.(now, installId) ?? require_eventId.createUUIDv7(),
+			installId,
+			...userId === null ? {} : { userId },
+			platform: context.platform,
+			appVersion,
+			cohort: context.getCohort(),
+			fingerprintHash: context.getFingerprintHash(),
+			sdkVersion: context.sdkVersion
+		};
+		const day = require_state.utcDay(now);
+		return {
+			body,
+			day,
+			report: movement.type === "UNCHANGED" || movement.type === "UPDATE_APPLIED" || movement.type === "RECOVERED" ? {
+				day,
+				channel: movement.channel,
+				appVersion,
+				bundleId: movement.toBundleId,
+				releaseId: movement.toReleaseId,
+				userId
+			} : null,
+			failureKey: null
+		};
+	};
+	const enqueue = (event) => {
+		if (event === null || send === null) return;
+		const { type, toBundleId } = event.body;
+		if (type === "UPDATE_DOWNLOADED" || type === "UPDATE_APPLIED") {
+			for (const queued of pending.values()) if (queued.body.type === "UPDATE_FAILED" && queued.body.toBundleId === toBundleId) queued.superseded = true;
+		}
+		pending.set(event.body, event);
+		send(event.body).catch((error) => {
+			console.warn(`[HotUpdater] Insights ${event.body.type} event was not delivered:`, error);
+		});
+	};
+	const reportLaunch = (channel, bundleId, releaseId, fromReleaseId) => {
+		if (didDownload) return;
+		enqueue(createEvent({
+			type: "UNCHANGED",
+			channel,
+			fromBundleId: null,
+			fromReleaseId,
+			toBundleId: bundleId,
+			toReleaseId: releaseId,
+			updateStrategy: null
+		}));
+	};
+	const onAppReady = (result) => {
+		if (result.status === "UNCHANGED") {
+			reportLaunch(result.channel, result.bundleId, result.releaseId, null);
+			return;
+		}
+		enqueue(createEvent({
+			type: result.status,
+			channel: result.channel,
+			fromBundleId: result.fromBundleId,
+			fromReleaseId: result.fromReleaseId,
+			toBundleId: result.toBundleId,
+			toReleaseId: result.toReleaseId,
+			updateStrategy: result.updateStrategy,
+			...result.status === "RECOVERED" && result.previousProcessExit !== null ? { metadata: { previousProcessExit: result.previousProcessExit } } : {}
+		}));
+	};
+	const onUpdateCheck = (result) => {
+		if (result.status !== "UNCHANGED") return;
+		reportLaunch(result.channel, result.bundleId, result.releaseId, result.previousReleaseId === result.releaseId ? null : result.previousReleaseId);
+	};
+	const onBundleDownloaded = (info) => {
+		const selection = JSON.stringify([
+			info.channel,
+			info.toReleaseId,
+			info.toBundleId
+		]);
+		if (lastDownloadedSelection === selection) return;
+		lastDownloadedSelection = selection;
+		didDownload = true;
+		enqueue(createEvent({
+			type: "UPDATE_DOWNLOADED",
+			channel: info.channel,
+			fromBundleId: info.fromBundleId,
+			fromReleaseId: info.fromReleaseId,
+			toBundleId: info.toBundleId,
+			toReleaseId: info.toReleaseId,
+			updateStrategy: info.updateStrategy,
+			metadata: {
+				delivery: info.delivery,
+				...info.patchFallback ? { patchFallback: true } : {}
+			}
+		}));
+	};
+	const onUpdateError = (error) => {
+		if (error.stage === "check" && error.reason === "network") return;
+		const targetBundleId = error.targetBundleId ?? error.bundleId;
+		const failureKey = [
+			error.stage,
+			error.reason,
+			targetBundleId
+		].join(" ");
+		const event = createEvent({
+			type: "UPDATE_FAILED",
+			channel: error.channel,
+			fromBundleId: error.bundleId,
+			fromReleaseId: error.releaseId,
+			toBundleId: targetBundleId,
+			toReleaseId: error.targetReleaseId ?? null,
+			updateStrategy: error.updateStrategy,
+			metadata: { failure: {
+				stage: error.stage,
+				reason: error.reason,
+				...error.resource === void 0 ? {} : { resource: error.resource },
+				...error.httpStatus === void 0 ? {} : { httpStatus: error.httpStatus },
+				...error.transport === void 0 ? {} : { transport: error.transport },
+				...error.originCode === void 0 ? {} : { originCode: error.originCode },
+				...error.previousProcessExit === void 0 ? {} : { previousProcessExit: error.previousProcessExit }
+			} }
+		}, (now, installId) => require_eventId.createKeyedUUIDv7([
+			installId,
+			require_state.utcDay(now),
+			failureKey
+		].join("\n"), require_state.utcDayStart(now)));
+		enqueue(event === null ? null : {
+			...event,
+			failureKey
+		});
+	};
+	const admit = (body) => {
+		const event = pending.get(body);
+		if (event === void 0 || state === null || context === null) return false;
+		if (event.superseded === true || state.isPaused(context.now())) {
+			pending.delete(body);
+			return false;
+		}
+		const admitted = body.type === "UNCHANGED" ? event.report === null || !state.repeatsReport(event.report) : body.type === "UPDATE_FAILED" ? event.failureKey === null || !state.hasFailure(event.day, event.failureKey) : true;
+		if (!admitted) pending.delete(body);
+		return admitted;
+	};
+	const settle = (body, delivery) => {
+		const event = pending.get(body);
+		pending.delete(body);
+		if (event === void 0 || state === null || context === null) return;
+		if (delivery === "failed") return;
+		if (delivery === "disabled") {
+			state.pause(context.now());
+			return;
+		}
+		if (event.failureKey !== null) state.recordFailure(event.day, event.failureKey);
+		if (delivery === "refused") return;
+		state.resume();
+		if (event.report !== null) state.recordReport(event.report);
+		else state.forgetReport();
+	};
+	return (0, _hot_updater_core.defineClientPlugin)({
+		id: "insights",
+		setup(pluginContext) {
+			context = pluginContext;
+			state = require_state.createInsightsState(pluginContext.storage);
+			if (pendingUser !== null) {
+				state.writeUserId(pendingUser.userId);
+				pendingUser = null;
+			}
+			if (pluginContext.isDebugBuild && options.debug !== true) return;
+			send = require_sender.createInsightsEventSender(pluginContext.fetch, {
+				admit,
+				settle
+			});
+			return {
+				onAppReady,
+				onUpdateCheck,
+				onBundleDownloaded,
+				onUpdateError
+			};
+		},
+		setUser(user) {
+			const userId = normalizeUserId(user);
+			if (state === null) {
+				pendingUser = { userId };
+				return;
+			}
+			state.writeUserId(userId);
+		}
+	});
+};
+//#endregion
+exports.insights = insights;

package/dist/client/index.d.cts

@@ -0,0 +1,42 @@
+import { HotUpdaterClientPlugin } from "@hot-updater/core";
+//#region src/client/index.d.ts
+interface InsightsOptions {
+  /**
+   * Also report from debug builds (`__DEV__`). Defaults to `false`, so
+   * development sessions stay out of production Insights.
+   */
+  readonly debug?: boolean;
+}
+/** The app's own id for the signed-in user, attached to later reports. */
+interface InsightsUser {
+  readonly userId: string | number;
+}
+interface InsightsPlugin extends HotUpdaterClientPlugin {
+  readonly id: "insights";
+  /**
+   * Attaches the signed-in user's id to later reports, or clears it with
+   * `null`. It persists on the device, sends nothing by itself, and can be
+   * called before `HotUpdater.init`.
+   */
+  setUser(user: InsightsUser | null): void;
+}
+/**
+ * Reports update adoption to a server that runs the `insights()` server
+ * plugin: launches (at most once a UTC day while nothing changes), downloads,
+ * applies, recoveries, and update failures. After the server answers that
+ * Insights is off, the plugin sends nothing for 24 hours, and for the rest
+ * of that runtime.
+ *
+ * @example
+ * ```ts
+ * import { HotUpdater } from "@hot-updater/react-native";
+ * import { insights } from "@hot-updater/react-native/plugins/insights";
+ *
+ * const analytics = insights();
+ * HotUpdater.init({ baseURL, plugins: [analytics] });
+ * analytics.setUser({ userId: "user-123" });
+ * ```
+ */
+declare const insights: (options?: InsightsOptions) => InsightsPlugin;
+//#endregion
+export { InsightsOptions, InsightsPlugin, InsightsUser, insights };