@zoho_apptics/apptics-js-sdk 1.0.2 → 2.0.0-beta.1

package/CHANGELOG.md

@@ -0,0 +1,193 @@
+# Change Log
+
+# Apptics JS SDK 2.0.0-beta.1
+Published under the `beta` npm tag; `latest` stays on 1.0.2. **Breaking for 2.0.0-beta code**: the changes are listed below, each with what to use instead.
+
+## The init() keys are base_url, auth_key and app_domain
+- `Apptics.init({ base_url, auth_key, app_domain, appversion })`, in place of 2.0.0-beta's `serviceUrl`, `zak` and `identifier`.
+- The earlier names still start the SDK, with a console warning naming the key to use: `serviceUrl` and 1.0.2's `base_domain` for `base_url`, `zak` and `token` for `auth_key`, `identifier` for `app_domain`. Data already stored in a browser is kept.
+
+## Every call is on the object of its feature
+Breaking for 2.0.0-beta code: each call keeps its name and moves onto the object of its feature, so an app imports only the objects.
+
+| 2.0.0-beta | Now |
+|---|---|
+| `ready()`, `flush()`, `reset()`, `enableDebug()`, `disableDebug()` | `Apptics.ready()`, `Apptics.flush()`, `Apptics.reset()`, `Apptics.enableDebug()`, `Apptics.disableDebug()` |
+| `AppticsTrackError(event, props)`, `enableGlobalErrorHandler(on)` | `AppticsError.trackError(event, properties)`, `AppticsError.trackGlobalErrorHandler(on)` |
+| `AppticsSetUser(userid, groupid, props)`, `getUser()`, `users.UserBuilder` | `AppticsUser.setUser(userid, groupid, props)`, `AppticsUser.getUser()`, `AppticsUser.UserBuilder` |
+| `setTrackingStatus(status)`, `getTrackingStatus()` | `AppticsSettings.setTrackingStatus(status)`, `AppticsSettings.getTrackingStatus()` |
+| `AppticsEvents.addEvent()` | `AppticsEvent.addEvent()` |
+| `AppticsScreenTracker.inScreen()`, `outScreen()` | `AppticsScreen.inScreen()`, `outScreen()` |
+| `AppticsApiTracker.startTrackApi()`, `endTrackApi()`, `configure()`, and `enableApiTracking(on)` | `AppticsApi.startTrackApi()`, `endTrackApi()`, `configure()`, `enableApiTracking(on)` |
+| `AP_TRACKING_STATUS` | `AppticsSettings.AP_TRACKING_STATUS` |
+| `AP_FEEDBACK_TYPE` | `AppticsFeedback.AP_FEEDBACK_TYPE` from `/feedback` |
+| `DefinedEvents` | `AppticsEvent.DefinedEvents` |
+| `ApiTrackingBuilder`, `UserBuilder` | `AppticsApi.ApiTrackingBuilder`, `AppticsUser.UserBuilder` |
+| `addFeedbackLog()`, `addDiagnosticsInfo()` | `AppticsFeedback.addFeedbackLog()`, `AppticsFeedback.addDiagnosticsInfo()` from `/feedback` |
+| `feedbackOpen(type, message, …)`, `feedbackClose()` from `/feedback` | `AppticsFeedback.feedbackFormOpen(options)`, `AppticsFeedback.feedbackFormClose()` from `/feedback` |
+| `sendFeedback(type, message, …)` from `/feedback` | `AppticsFeedback.sendFeedback({ type, message, attachments, logFiles, includeDiagnostics, includeLog, isAnonymous })` |
+| `enableHeatmap(on)` from `/heatmap` | `AppticsHeatmap.trackHeatmap(on)` from the main entry |
+
+- `AppticsEvents` is `AppticsEvent`; `AppticsLogger` and `AppticsRemoteConfig` keep their names. The package exports only the objects: `DefinedEvents` is `AppticsEvent.DefinedEvents`, `ApiTrackingBuilder` is `AppticsApi.ApiTrackingBuilder`, and `UserBuilder` is `AppticsUser.UserBuilder`.
+- The feedback form has a theme: `feedback_theme: 'light' | 'dark' | 'auto'` (default `auto`, the visitor's system setting), colors as `--zasdk-*` CSS variables a page can override, and the previously hard-coded colors of the user picker, toggles and data viewer now follow the theme. The form is a labelled modal dialog: it takes focus on open, Escape closes it, and the close control works from the keyboard. The textarea placeholder uses the page font, and the counter reads "characters left".
+- `AppticsFeedback.setFeedbackTheme('light' | 'dark' | 'auto')` changes the theme after `Apptics.init()`, restyling a form that is open, for pages with their own theme switch: `auto` follows the operating system, not the page.
+- The feedback form's System Logs viewer shows each time in the visitor's local zone (`16 Oct 2026, 11:53:48 PM IST`). The `feedbacklog.txt` sent with the report is unchanged: it keeps ISO 8601 UTC stamps.
+- The feedback form lists Feedback first, then Bug, Help and Report, and opens with Feedback selected. The type values (`AP_FEEDBACK_TYPE`) are unchanged.
+- `AppticsHeatmap` is on the main entry. There is no `/heatmap` entry or `heatmap.esm.min.js` any more.
+- `AppticsLogger` is on its own entry point, `@zoho_apptics/apptics-js-sdk/remote-logger`, and the main entry has no `AppticsLogger`. The `<script>` build still defines it as a global.
+- Every feedback call, `addFeedbackLog()` and `addDiagnosticsInfo()` included, is on the `/feedback` entry's `AppticsFeedback`. The main entry has no `AppticsFeedback`.
+- The `<script>` build defines every object as a global: `Apptics`, `AppticsEvent`, `AppticsScreen`, `AppticsApi`, `AppticsError`, `AppticsUser`, `AppticsSettings`, `AppticsFeedback`, `AppticsLogger`, `AppticsRemoteConfig`, `AppticsHeatmap`. The `AppticsEvents`, `AppticsScreenTracker`, `AppticsApiTracker`, `AppticsTrackError` and `AppticsSetUser` globals are gone.
+- The TypeScript type for the whole API, `AppticsApi` in 2.0.0-beta, is `AppticsSdk`: `AppticsApi` is the API-tracking object now.
+
+## The feedback form brings its own styles
+- `AppticsFeedback.feedbackFormOpen()` adds the form's stylesheet to the page the first time it opens, so npm apps no longer `import '@zoho_apptics/apptics-js-sdk/style.css'`. The CDN builds carry the styles too, so no app imports or links a css file, and `style.css` is no longer a published file.
+
+## Screen recording is set up in the console
+- `DC`, `quartz_workspace_key` and `quartz_department_key` are no longer `Apptics.init()` keys: the form takes its recording settings from `getsdkconfig` and loads the script it needs itself. `Apptics.init()` warns when it is still given them.
+
+## The remote logger is the app's own lines, logged directly
+- `AppticsLogger.verbose`, `debug`, `info`, `warn` and `error(message, properties?)`, in place of 2.0.0-beta's `v`, `d`, `i`, `w` and `e(tag, message)`. `properties` is appended to the message: an object as JSON, an `Error` as its stack.
+- No switch: `AppticsLogger.enable()`, `disable()` and `isEnabled()` are removed, and a line is recorded as it is written (while the server has the remote logger on and tracking is allowed).
+- The SDK no longer sends its own failures to the Remote Logger page: the `remote_log` option is removed, and `Apptics.init()` warns when it is still given it.
+- Same levels, 1 to 5; the tag is gone, since the Remote Logger page does not use it.
+- The `show_logs` option is removed: `AppticsLogger` lines go to the Remote Logger page only, and are not printed to the browser console. `Apptics.init()` warns when it is still given it.
+
+## Remote config follows the console's condition order
+- A parameter takes the value of the first condition, in the order of the console's `all_condition` list, that matches this device; none matches, its default value. 2.0.0-beta went by each parameter's `conditionorder`.
+- **`setCustomConditionValue(conditionname, values)`**: a custom condition (`custom_sdk_value`) is answered by its condition name, with this device's values comma separated, and matches when one of them is listed. 2.0.0-beta took the criteria key. Values are for the page, no longer stored across visits.
+- **`country`** criteria: the country `AppticsUser.setUser` registered, else the country of the browser's time zone (`Asia/Kolkata`, or Chrome's `Asia/Calcutta`: India), from a table generated from tzdata by `scripts/tz-countries.mjs`.
+- `fetchValues(names?)` takes a list of parameter names, `fetchValues(['primaryColor', 'maxItems'])`, in place of 2.0.0-beta's `{ name: default }` object: each value's default comes from the console, and a name the console doesn't have is `null`. With no names it answers with every parameter.
+- `AppticsRemoteConfig.setFallbackWithOfflineValue` is removed: a failed fetch answers with the values fetched before, as it did by default.
+- `coldFetch` is removed from `fetchValue` and `fetchValues`: a fetch from the last five minutes answers later reads, and the SDK asks the server again once it is older.
+
+## Feedback calls take one options object
+- `AppticsFeedback.feedbackFormOpen({ type, message, includeLog, includeDiagnostics, attachments, logFiles, isAnonymous })` and `AppticsFeedback.sendFeedback({ type, message, attachments, logFiles, includeDiagnostics, includeLog, isAnonymous })`, in place of their long lists of arguments; every key is optional. `includeDyninfo` is `includeDiagnostics`.
+- `sendFeedback` is sent from the user `AppticsUser.setUser` set, or from nobody with `isAnonymous: true`. It used to go from whoever the form's user picker last chose, which was nobody until the form had been opened.
+- `feedbackOpen` and `feedbackClose` are `feedbackFormOpen` and `feedbackFormClose`.
+- The old one-after-another form is answered safely: `feedbackFormOpen(type, …)` opens the form with its defaults and a warning, and `sendFeedback(type, …)` rejects rather than send an empty report.
+- Feedback is sent even when tracking is off (`NO_TRACKING`): only the feedback goes.
+
+## API tracking rules: equals and regex, to allow or to ignore
+- `ApiTrackingBuilder` has four rules: `allowEquals`, `allowRegex`, `ignoreEquals` and `ignoreRegex`, each tried on the call's URL without its query. An ignore always wins; with allow rules, a call must match one.
+- `ignoreDomains`, `allowOnlyDomains`, `allowOnlyTLDs`, `ignoreTLDs`, `ignoreDomainPrefixes`, `ignoreDomainSuffixes`, `groupDomains`, `ignoreEndpoint`, `addPattern`, `preserveSegments` and `autoDetection` are removed; calling one throws a `TypeError` naming what to use. Ids, UUIDs and tokens in a path still become `*` on their own.
+- A call reported by its parts (a `hostname` and a `path`) is recorded with its own scheme and port, `https` and 443 unless given, not the page's.
+
+## screen_routes takes exact paths and regular expressions
+- Beside route patterns (`'/users/{id}/orders'`), `{ equals: '/', name: 'Home' }` and `{ regex: /^\/orders\/\d+$/, name: 'Order detail' }` name a path; entries are tried in order. An entry that cannot be used is left out, and said.
+
+## Heatmaps: trackHeatmap
+- `AppticsHeatmap.trackHeatmap(on?)` starts or stops capture.
+
+## Sessions are always recorded
+- The `track_session` option is removed: every event, screen and error belongs to a session, so there is no tracking without one. An app that wants nothing recorded uses `AppticsSettings.setTrackingStatus(AppticsSettings.AP_TRACKING_STATUS.NO_TRACKING)`. `Apptics.init()` warns when it is still given `track_session`.
+
+## Storage is tidier
+- IndexedDB's stores and keys are renamed: each record's order key `seq` is `queue`, the remote logger's store `consolelogs` is `remotelogs`, and the feedback store `logs` is `feedbacklogs`, whose entries are of type `feedbacklog` and `feedbackdiagnostics` (were `log` and `diagnostics`). The localStorage fallback's keys follow. A browser that ran 2.0.0-beta is moved over on its first load, with everything queued kept.
+- The settings store no longer has `appkey`, `appversion`, `hadsession`, `token`, `tracking_status` or `uuid`: the app and its version are read from `app_version_info`, the tracking status is in `trackinfo`, and the uuid and `hadsession` are in `device_info`. They are moved there on the first load, so a browser stays the same device and keeps the visitor's choice. `user_info` holds the user `AppticsUser.setUser` registered.
+
+## Fixes
+- `AppticsFeedback.addDiagnosticsInfo(heading, key, value)` requires the value: an entry without one (or without a heading or key) is not recorded, and the console says why. It used to store an empty value silently.
+- A `<script>`, `<img>` or `<link>` that fails to load is tracked as a JS error: its `error` event does not bubble, so it never reached the SDK's listener.
+- One visit with Do Not Track on no longer switches tracking off for good: it was stored as the visitor's own choice, so tracking stayed off after Do Not Track was turned off or `ignore_do_not_track` set.
+- A first visit with no network starts once the browser is back online, keeping what was tracked meanwhile; it used to give up for the rest of the page.
+- Stored data waits for `device/add` to answer instead of going out without a `deviceid`.
+- A scroll still settling when heatmaps are switched off (a single-page app leaving a heatmap page) is recorded, not dropped.
+- `AppticsFeedback.sendFeedback()` refuses more than 5 attachments or more than 10 MB, as the form does; it used to send none of them while saying they were there.
+- An invalid event, group or screen name is said in the console once, with console logging off too.
+- A browser console showed every public call as `(...args)`. Each one now shows its own parameter names, as `addEvent(eventName, groupName, properties)`, in the npm and the minified CDN builds alike.
+- A remote logger line typed in the browser's developer console is sent with function `-`, filename `-` and line 0, instead of the console's `<anonymous>` (Chrome, Edge), `code` (Firefox) or nothing (Safari).
+- `getsdkconfig` is no longer called at start-up straight after `app/addversion`. It is called once `device/add` has succeeded, then every `getupdates_interval` (2 minutes by default) and when the page comes back into view; a returning visit starts from the settings the last one saved.
+- Heatmap scroll records were never stored on pages that scroll a content pane rather than the window, as app layouts do: the gesture was measured on the window, which had not moved. The pane that scrolled is measured now, when it covers at least half the viewport each way, so a dropdown list scrolling is still not counted.
+- Automatic screen tracking lost pages in Next.js and other routers that replaceState the same url right after a route change: the page was not recorded and the view before it was never ended.
+- A screen view left open by a tab that reloaded, closed or crashed stayed open until the session ended. A tab now ends such views when it starts or comes back into view, at the time their tab was last seen (Web Locks; browsers without them end the views with their session, as before).
+- A promise rejected with an `Event`, such as a failed script or image load, was reported as "[object Event]". It is named by the event and the element it came from; a rejection with a plain object by its JSON.
+- Click tracking reads `data-apeventaction`, `data-apgroupaction` and `data-apeventprops` too, the spelling React and TypeScript accept without declaring the attributes.
+- `getupdates` (remote config) no longer carries `userid` and `customergroupid` once a user is set; the server refused them as `EXTRA_PARAM_FOUND`. Conditions on the user are still applied, on the device.
+- Two tabs opened together on a first visit registered the browser twice. Registration now runs under a lock shared by the site's tabs, and a tab finding another's registration in storage uses it.
+- Tabs of a site share one session, and closing one of them no longer ends it for the others: the session ends when the last tab closes.
+- A `base_url` on localzoho reports framework id 5970, the id localzoho issued for 2.0.0-beta, instead of the one issued by sdk-apptics.zoho.com, which localzoho refuses as `INVALID_FRAMEWORK`.
+
+# Apptics JS SDK 2.0.0-beta
+A rewrite of the web SDK in TypeScript, published on npm as ES modules, CommonJS and a minified browser build. Published under the `beta` npm tag; `latest` stays on 1.0.2. **`Apptics.init()` takes new config**: see "Migrating from 1.0.2 to 2.0.0-beta.1" in the README. Runs in Chrome 80+, Edge 80+, Firefox 74+ and Safari 14+.
+
+## Initialization
+- **The Android SDK's names**: `Apptics.init(config)`, `AppticsEvents.addEvent`, `AppticsScreenTracker.inScreen` / `outScreen`, `AppticsApiTracker.startTrackApi` / `endTrackApi` / `configure`, `AppticsLogger.enable` / `disable` / `isEnabled` / `v` / `d` / `i` / `w` / `e`, `AppticsTrackError`, `AppticsSetUser`, and `AppticsRemoteConfig`. The `<script>` build defines them as globals too. 1.0.2's `apptics.init`, `apptics.trackEvent`, `apptics.trackScreen`, `apptics.trackError` and `apptics.setUser` are gone, so code calling them has to be renamed.
+- **New config**: `Apptics.init()` takes `serviceUrl`, `zak`, `identifier` and `appversion`, all required. The SDK gets `aaid`, the portal id and the project id from the server, so `aaid`, `zsoid` and `projectID` are no longer passed in. A missing key is named in a console warning and `Apptics.init()` returns `false`.
+- **`appversion` is required**: 1.0.2 defaulted it to `1.0`, which attributed every session, error and crash to a version that was never shipped.
+- **`appversion` takes a string or a number**: `'2.4.0'`, `'v2.4-build512'` or a build number such as `512`. It is sent as text: a string is trimmed, and a number keeps the digits JavaScript gives it (`1.10` is `'1.1'`), so pass a dotted version as a string. A blank value, or a snippet placeholder (`YOUR_APP_VERSION`, `YOUR_BUILD_OR_APP_VERSION`, `YOUR_APPVERSION`), is refused with a console warning and `Apptics.init()` returns `false`.
+- **`ready()`**: a Promise that resolves once the SDK is running. Calls made between `Apptics.init()` and that point are queued and replayed in order.
+- Calls that track or send something before `Apptics.init()` are ignored, and the first one logs a console warning saying so.
+- **`mute()` and `unmute()` are removed.** `setTrackingStatus(AP_TRACKING_STATUS.NO_TRACKING)` stops tracking, and unlike `mute()` it is stored across visits.
+- Safe to import during server-side rendering; nothing runs until `Apptics.init()` is called in the browser. Public calls never throw into the host app.
+- **Storage**: IndexedDB with a localStorage fallback. Data stored by 1.0.2 is migrated on the first visit. Queued items are stored one per record and a Web Lock keeps two tabs from sending the same data.
+
+## Packaging and CDN
+- **npm**: `import` and `require()` both work, with type declarations. Optional modules are separate entry points, so apps ship only what they use: `@zoho_apptics/apptics-js-sdk/feedback`, `/heatmap`, `/remote-config` and `/style.css`.
+- **One script tag**: the CDN builds (`apptics.min.js`, `feedback.esm.min.js`) load the feedback form's `style.css` themselves, so a page needs no separate `<link>`. `apptics.min.js` includes every module on `window.apptics`.
+- **License**: the Zoho Apptics JavaScript SDK license (see LICENSE) instead of MIT. It allows installing from npm or a CDN, bundling with your build tools and serving the SDK to your users as part of your web app.
+
+## Events
+- **Defined events, as on Android**: `AppticsEvents.addEvent(DefinedEvents.AP_USER_LOGIN, props?)` logs Apptics' ready-made events under their own `AP_` groups.
+- **`ap_` / `AP_` is reserved**: an app's event, group or property key starting with it is not logged.
+- **An event with an invalid group is not logged**, as on Android, instead of being filed under `default`; an event with no group is still `default`.
+- **Properties are judged one by one**: a bad key or an over-long value drops that property, and the event keeps the rest (it used to lose them all). Booleans are typed as Boolean and every number as Number (`1` and `0` were typed as Boolean); objects and arrays are sent as JSON text.
+
+## Sessions
+- **`track_session: false`** turns automatic sessions off, as Android's `automaticSessionsTrackingStatus = false`; events and screens are still recorded.
+
+## Screen Tracking
+- **`trackScreen()` is renamed `AppticsScreenTracker.inScreen()`**, as in the Android SDK: same arguments, and it returns the view's id for `AppticsScreenTracker.outScreen(id)`. `trackScreen` no longer exists, so 1.0.2 code calling it has to be renamed.
+- **Screen views have a duration.** A view ends when the next screen starts, when the page is hidden (coming back starts a new view), or when its session ends. `AppticsScreenTracker.inScreen()` now returns the view's id, and `AppticsScreenTracker.outScreen(id)` ends it yourself, as Android's `outScreen`. Until now every view was recorded with no time spent.
+- **Automatic screen tracking, on by default**: the first page and every navigation (`pushState`, `replaceState`, back and forward, `#/` hash routes) are recorded as screens, named by the path without its query string. A `AppticsScreenTracker.inScreen()` from the router names a route your own way. A `AppticsScreenTracker.inScreen()` call within 300 ms of a navigation (from a router hook) replaces the automatic view, so the navigation counts once under the app's name; `track_screen: false` turns automatic tracking off.
+- **`setScreenName()` is removed.** Records are attributed to the screen `AppticsScreenTracker.inScreen()` or automatic tracking last named; heatmap records with neither get the page's name, made from its path the same way.
+
+## Remote Logger
+- **`AppticsLogger`**: `AppticsLogger.v/d/i/w/e(tag, message, ...details)` sends the app's log lines to the Remote Logger page, as levels 1 to 5 in the Android and iOS order. Off until `AppticsLogger.enable()`; `AppticsLogger` in the `<script>` build. Each line carries the time it was logged and the function, file and line that logged it.
+- **Android's names too**: `AppticsLogger.v/d/i/w/e(tag, message)`, with the tag leading the message as `[tag]`, and `AppticsLogger.disable()`.
+- **`show_logs: true`** prints the app's lines to the browser console as well, as Android's `showLogs` does for Logcat.
+- **Offline storage is capped at 1 MB**, oldest lines dropped first, as on Android (instead of 200 lines).
+- **SDK diagnostics**: the SDK reports its own failures to the same page, tagged with the module it happened in. Off by default; `remote_log: true` turns it on, independently of `AppticsLogger`.
+
+## API Tracking
+- **Path normalization, as on Android**: numeric ids, UUIDs and JWTs in a path become `*`, and the query string is removed, so calls group by endpoint (`/users/42/orders` → `/users/*/orders`).
+- **`AppticsApiTracker.configure(new ApiTrackingBuilder()...build())`** with Android's rules: `ignoreDomains`, `allowOnlyDomains`, `allowOnlyTLDs`, `ignoreTLDs`, `ignoreDomainPrefixes`, `ignoreDomainSuffixes`, `groupDomains`, `ignoreEndpoint`, `addPattern`, `preserveSegments`, `autoDetection`. They apply to every call.
+- **`AppticsApiTracker.startTrackApi(url, method)` / `AppticsApiTracker.endTrackApi(id, code)`** time and record a call, as on Android.
+- **`track_api: true`** records every `fetch` and XHR call automatically (`enableApiTracking(on)` switches it later); a call is reported by hand with `AppticsApiTracker.startTrackApi` / `endTrackApi`. The SDK's own requests are never recorded. Host rules are set only through `AppticsApiTracker.configure`: the earlier `track_api_hosts` / `track_api_exclude_hosts` keys are gone, and `Apptics.init()` warns when it is given them.
+
+## Remote Config
+- **`AppticsRemoteConfig`** from `@zoho_apptics/apptics-js-sdk/remote-config` (`AppticsRemoteConfig` in the `<script>` build): four calls, as on Android: `fetchValue(name)` and `fetchValues({ name: default })` read parameters, `setCustomConditionValue` and `setFallbackWithOfflineValue` (below). The rule set is stored and resolved on the device, and conditions on the user re-apply on their own after `AppticsSetUser`.
+- **`setCustomConditionValue(key, value)`**, as on Android: conditions on a custom criteria match this device's value. Kept across visits; works before `Apptics.init()`.
+- **`fetchValue(name)`** and **`fetchValues({ name: default })`**, as on Android: Promises, with an optional callback. A parameter the console doesn't have is `null`.
+- **Fetched on start-up**, so values are this session's without the app asking.
+- **A fetch from the last five minutes is reused**; `coldFetch` asks the server regardless, at most three times a minute.
+- **`setFallbackWithOfflineValue(false)`**: a failed fetch answers with `null` and defaults instead of the values fetched before (the default).
+
+## Heatmap
+- **Every heatmap record has its screen view in `engagement/add`**: when nothing has named the screen (automatic screen tracking off, no `AppticsScreenTracker.inScreen()`), the first record on a page records a view of it, so the console can place the record.
+- **Heatmaps**: clicks (with rage and dead clicks) and scrolls, for the Apptics console. Off by default; `track_heatmap: true` plus an import of `@zoho_apptics/apptics-js-sdk/heatmap`. An element's visible text is used for its label only with `USAGE_TRACKING_WITH_PII`.
+
+## Debugging
+- **Debug mode**: `debug: true` in `Apptics.init()`, or `enableDebug()` / `disableDebug()` at any time, with or without `Apptics.init()`. Payloads go to the debug endpoints, for following in the Apptics web console. What the app sets with the functions wins over the `Apptics.init()` option; debug mode switches itself off after an hour with nothing tracked.
+- **`debug` now means debug mode.** In 1.0.2 it turned on browser-console logging.
+
+## Feedback
+- **`sendFeedback()`** returns a Promise that resolves once the feedback is sent and rejects when it wasn't (SDK not started, offline, server refusal). It takes `includeLog` as a sixth argument; `includeLog` and `includeDyninfo` send their file when there is something stored, unless set to `false`.
+- `addFeedbackLog()` and `addDiagnosticsInfo()` are on the main entry point, so recording context doesn't pull the form into a bundle. `dyninfo.txt` carries the diagnostics and a `[Device Info]` block. Stored entries are capped at 1,000, and 10,000 characters per message.
+
+## Server APIs
+- Every call goes to the v2 APIs. Logs are sent in batches, and the server's per-module settings (`getsdkconfig`) are honoured: a module the server switches off stops recording and sending.
+
+## Fixes (2.0.0-beta)
+- Queued engagements, errors and heatmap records are removed only once the server accepts them; a failed send (5xx, timeout, CORS, dropped connection) goes again instead of being lost.
+- Page-close sends stay within the browser's 64 KiB keepalive limit; a larger batch is kept for the next visit.
+- The flush timer never sent errors; engagements, errors and heatmaps now go out in turn.
+- The server's "stop tracking" signal was ignored.
+- `ignore_do_not_track: true` disabled tracking instead of ignoring the browser's Do Not Track setting.
+- Click tracking with `apeventaction` required jQuery.
+- The SDK crashed without `screen.orientation`.
+- Send timers multiplied on every reconnect; devices were registered twice; the device update on an app-version change was sent empty.
+- A successful error send wiped errors recorded while it was in flight.
+- Requests now time out after 30 seconds, and ids in request URLs are encoded.
+
+# Apptics JS SDK 1.0.2
+- First releases on npm (1.0.0, 1.0.1 and 1.0.2, August 2025). The SDK ran alongside the Apptics console snippet and exported nothing for `import` or `require()`.

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2025 Zoho Corporation Private Limited
+
+Zoho grants you a limited, revocable, non-exclusive, non-sublicensable license to copy, install and use the Zoho Apptics JavaScript SDK (the "SDK") solely in connection with your use of Zoho Apptics in your websites and web applications. This license includes the right to:
+(a) install the SDK from a package registry such as npm, or load it from a content delivery network;
+(b) bundle, transpile, minify or otherwise process the SDK with your web application's build tools; and
+(c) serve the SDK, processed only as described in (b), to your end users' browsers as part of your website or web application.
+
+You will not:
+(i) modify, adapt, translate or otherwise create derivative works of the SDK, except as permitted in (b);
+(ii) reverse engineer, deobfuscate, decompile, disassemble or otherwise attempt to discover the source code of the SDK;
+(iii) rent, sell, assign, sublicense or otherwise transfer rights in the SDK, or distribute it other than as part of your website or web application as permitted in (c);
+(iv) remove any proprietary notices or licenses from the SDK; or
+(v) use, post, publish, transmit or introduce any device, software or routine that interferes or attempts to interfere with the operation of the SDK or of Zoho Apptics.