@zoho_apptics/apptics-js-sdk 2.0.0-beta → 2.0.0-beta.2

package/dist/esm/errors/track.d.ts

@@ -1,4 +1,5 @@
 import type { Properties } from '../types.js';
 export declare function trackError(errorEvent: any, jsonObj?: Properties): void;
-export declare function enableGlobalErrorHandler(status?: boolean): void;
+/** AppticsError.setErrorTracking: uncaught errors on or off, as the `track_error` config sets it. */
+export declare function setErrorTracking(status?: boolean): void;
 export declare function extractMethodNameFromStackTrace(stackTrace: string): string;

package/dist/esm/errors/track.js

@@ -1,4 +1,4 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { AP_CONSTANTS } from '../core/constants.js';
 import { _ZAP } from '../core/state.js';
 import { Console } from '../core/logger.js';
@@ -36,19 +36,59 @@ function stackOf(errorEvent) {
 }
 /** Said in place of a stack when there is none, so `message` is never sent empty. */
 const NO_STACK = 'no stack available'; // no i18n
+/** The element an event came from, as `<script src="…">`, so a failed load says what failed. */
+function describeTarget(target) {
+    var el = target;
+    if (!el || typeof el.tagName !== 'string') { // no i18n
+        return ''; // no i18n
+    }
+    var tag = el.tagName.toLowerCase();
+    var url = el.currentSrc || el.src || el.href || ''; // no i18n
+    return ' on <' + tag + (url ? (el.href && !el.src ? ' href="' : ' src="') + url + '"' : '') + '>'; // no i18n
+}
+/**
+ * What was thrown or rejected, as text an issue can be named by. An Error reads as itself. A
+ * promise rejected with an Event - what a failed script or image load hands over - used to be
+ * recorded as "[object Event]"; it is named by its type and where it came from instead. Anything
+ * else that is an object is shown as its JSON, cut short.
+ */
+function describeThrown(thrown) {
+    if (thrown === null || thrown === undefined) {
+        return ''; // no i18n
+    }
+    if (typeof thrown !== 'object') { // no i18n
+        return String(thrown);
+    }
+    if (thrown instanceof Error || typeof thrown.message === 'string' && typeof thrown.name === 'string') { // no i18n
+        return String(thrown);
+    }
+    if (typeof Event !== 'undefined' && thrown instanceof Event) { // no i18n
+        return 'Event "' + thrown.type + '"' + describeTarget(thrown.target); // no i18n
+    }
+    var text = String(thrown);
+    if (text !== '[object Object]') { // no i18n
+        return text;
+    }
+    try {
+        return JSON.stringify(thrown).slice(0, 300);
+    }
+    catch (err) {
+        return text;
+    }
+}
 function trackError(errorEvent, jsonObj) {
     if (!canTrackErrors('trackError')) { // no i18n
         return;
     }
     if (isEmpty(errorEvent)) {
-        Console.warn('AppticsTrackError: Invalid error'); // no i18n
+        Console.warn('AppticsError.trackError: Invalid error'); // no i18n
         return;
     }
     var _jsonObj = validateJSON(jsonObj);
     var stack = stackOf(errorEvent);
     var methodName = extractMethodNameFromStackTrace(stack) || "";
     var issuetype = errorEvent.type || "";
-    var thrown = errorEvent.reason || errorEvent.error || errorEvent.message || "";
+    var thrown = describeThrown(errorEvent.reason || errorEvent.error || errorEvent.message || "");
     // "Error: x at handler", or just "Error: x" when the stack names no method. issuename is
     // required too, so something that carried no message at all is still named rather than blank
     var described = !isEmpty(String(thrown)) ? String(thrown) : (!isEmpty(issuetype) ? String(issuetype) : 'Unknown error'); // no i18n
@@ -74,11 +114,13 @@ function trackError(errorEvent, jsonObj) {
     commitPendingSession();
     noteDebugActivity();
     error_transactions.add(errorData);
-    Console.log('AppticsTrackError(\'' + issuetype + '\',\'' + message + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
+    Console.log('AppticsError.trackError(\'' + issuetype + '\',\'' + message + '\',' + JSON.stringify(_jsonObj || {}) + ')'); // no i18n
     Console.dir(errorData);
 }
-function enableGlobalErrorHandler(status) {
-    _ZAP._isGlobalErrorTracking = typeof status === "boolean" ? status : true; // no i18n
+/** AppticsError.setErrorTracking: uncaught errors on or off, as the `track_error` config sets it. */
+function setErrorTracking(status) {
+    _ZAP._config.track_error = typeof status === "boolean" ? status : true; // no i18n
+    Console.log('automatic error tracking: ' + (_ZAP._config.track_error ? 'on' : 'off')); // no i18n
 }
 function extractMethodNameFromStackTrace(stackTrace) {
     let methodName = ''; // no i18n
@@ -120,4 +162,4 @@ function extractMethodNameFromStackTrace(stackTrace) {
     return methodName;
 }
 
-export { enableGlobalErrorHandler, extractMethodNameFromStackTrace, trackError };
+export { extractMethodNameFromStackTrace, setErrorTracking, trackError };

package/dist/esm/feedback/controls.d.ts

@@ -12,6 +12,12 @@ export declare const logChoice: {
     includeLog?: boolean;
     includeDyninfo?: boolean;
 };
+/**
+ * Who a sendFeedback() report, made without the form, is attributed to: nobody when `anonymous`,
+ * else the user AppticsUser.setUser set (or the active registered one, status 1). Returns a function
+ * that puts back the choice that was there, so a form left open keeps its own.
+ */
+export declare function chooseUserForSend(anonymous: boolean): () => void;
 /**
  * The "User" dropdown above the description. It lists Anonymous plus every registered user, and
  * starts on the active one (status 1) unless the caller asked for anonymous.
@@ -29,3 +35,9 @@ export declare function wireLogControls(modal: HTMLElement, opts: Dict): void;
  * kept inside the viewport.
  */
 export declare function wireDrag(box: HTMLElement): void;
+/**
+ * Lets the recording timer be dragged anywhere on the page. A press that moves it is a drag, and
+ * does not also stop the recording, as a plain click on it does. Call before the click listener
+ * is added, so a drag's click is stopped ahead of it.
+ */
+export declare function wireTimerDrag(timer: HTMLElement): void;

package/dist/esm/feedback/controls.js

@@ -1,8 +1,9 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
 import { Console } from '../core/logger.js';
 import { hooks } from '../core/hooks.js';
 import { user_defaults } from '../core/storage.js';
 import { isEmpty } from '../core/utils.js';
+import { _ZAP } from '../core/state.js';
 import { hasLogLines, hasDiagnostics, logText, diagnosticsText } from './logs.js';
 
 /**
@@ -23,6 +24,34 @@ function resetUserChoice() {
     userChoice.userid = ''; // no i18n
     userChoice.groupid = ''; // no i18n
 }
+/**
+ * Who a sendFeedback() report, made without the form, is attributed to: nobody when `anonymous`,
+ * else the user AppticsUser.setUser set (or the active registered one, status 1). Returns a function
+ * that puts back the choice that was there, so a form left open keeps its own.
+ */
+function chooseUserForSend(anonymous) {
+    var before = { anonymous: userChoice.anonymous, userid: userChoice.userid, groupid: userChoice.groupid };
+    resetUserChoice();
+    if (!anonymous) {
+        // the user setUser set on this page, else the active one of those registered before
+        var active = !isEmpty(_ZAP._user_info.userid) ? _ZAP._user_info : null;
+        storedUsers().forEach(function (user) {
+            if (!active && user && user.status == 1 && !isEmpty(user.userid)) {
+                active = user;
+            }
+        });
+        if (active) {
+            userChoice.anonymous = false;
+            userChoice.userid = String(active.userid);
+            userChoice.groupid = String(active.groupid || ''); // no i18n
+        }
+    }
+    return function restore() {
+        userChoice.anonymous = before.anonymous;
+        userChoice.userid = before.userid;
+        userChoice.groupid = before.groupid;
+    };
+}
 /** Every distinct registered user, by the address the picker shows. */
 function storedUsers() {
     var users = user_defaults.item('users'); // no i18n
@@ -236,45 +265,93 @@ function wireDrag(box) {
     if (!header) {
         return;
     }
-    var startX = 0, startY = 0, boxLeft = 0, boxTop = 0, dragging = false;
-    header.addEventListener('mousedown', function (event) {
-        if (event.target.closest('.zasdk-close')) { // no i18n
-            return; // the close button is not a drag handle
-        }
-        if (!box.style.left || box.style.left === 'auto') { // no i18n
-            var rect = box.getBoundingClientRect();
-            box.style.right = 'auto'; // no i18n
-            box.style.bottom = 'auto'; // no i18n
-            box.style.left = rect.left + 'px'; // no i18n
-            box.style.top = rect.top + 'px'; // no i18n
+    makeDraggable(box, header, function (target) {
+        // the close button is not a drag handle
+        return !!target.closest('.zasdk-close'); // no i18n
+    });
+}
+/** Where the recording timer was last dragged to, so the next recording's timer starts there. */
+var timerSpot = null;
+/**
+ * Lets the recording timer be dragged anywhere on the page. A press that moves it is a drag, and
+ * does not also stop the recording, as a plain click on it does. Call before the click listener
+ * is added, so a drag's click is stopped ahead of it.
+ */
+function wireTimerDrag(timer) {
+    if (timerSpot) {
+        placeAt(timer, timerSpot.left, timerSpot.top);
+    }
+    makeDraggable(timer, timer, undefined, function (left, top) {
+        timerSpot = { left: left, top: top };
+    });
+}
+/** Puts a fixed box at left/top, inside the viewport. */
+function placeAt(box, left, top) {
+    box.style.right = 'auto'; // no i18n
+    box.style.bottom = 'auto'; // no i18n
+    box.style.left = Math.max(0, Math.min(left, window.innerWidth - box.offsetWidth)) + 'px'; // no i18n
+    box.style.top = Math.max(0, Math.min(top, window.innerHeight - box.offsetHeight)) + 'px'; // no i18n
+}
+/**
+ * Moves `box` with the mouse or a finger pressed on `handle`. `skip` says which presses are not a
+ * drag; `moved` hears where the box ended up. A click that ends a drag goes no further.
+ */
+function makeDraggable(box, handle, skip, moved) {
+    var startX = 0, startY = 0, boxLeft = 0, boxTop = 0, dragging = false, dragged = false;
+    handle.addEventListener('pointerdown', function (event) {
+        if (event.button !== 0 || (skip && skip(event.target))) {
+            return;
         }
+        var rect = box.getBoundingClientRect();
         dragging = true;
+        dragged = false;
         startX = event.clientX;
         startY = event.clientY;
-        boxLeft = parseInt(box.style.left, 10);
-        boxTop = parseInt(box.style.top, 10);
-        header.style.cursor = 'grabbing'; // no i18n
+        boxLeft = rect.left;
+        boxTop = rect.top;
+        handle.style.cursor = 'move'; // no i18n
+        // the moves and the release come to the handle however far the pointer goes, so nothing
+        // is left listening on the document once the box is gone
+        try {
+            handle.setPointerCapture(event.pointerId);
+        }
+        catch (err) { /* a pointer already released */ }
         event.preventDefault();
     });
-    document.addEventListener('mousemove', function (event) {
+    handle.addEventListener('pointermove', function (event) {
         if (!dragging) {
             return;
         }
-        var left = boxLeft + (event.clientX - startX);
-        var top = boxTop + (event.clientY - startY);
-        box.style.left = Math.max(0, Math.min(left, window.innerWidth - box.offsetWidth)) + 'px'; // no i18n
-        box.style.top = Math.max(0, Math.min(top, window.innerHeight - box.offsetHeight)) + 'px'; // no i18n
-    });
-    document.addEventListener('mouseup', function () {
-        if (dragging) {
-            dragging = false;
-            header.style.cursor = 'grab'; // no i18n
+        var dx = event.clientX - startX, dy = event.clientY - startY;
+        if (!dragged && Math.abs(dx) < 4 && Math.abs(dy) < 4) {
+            return; // a press that wobbles is still a click
         }
+        dragged = true;
+        placeAt(box, boxLeft + dx, boxTop + dy);
     });
+    function stop() {
+        if (!dragging) {
+            return;
+        }
+        dragging = false;
+        handle.style.cursor = ''; // no i18n
+        if (dragged && moved) {
+            moved(parseInt(box.style.left, 10), parseInt(box.style.top, 10));
+        }
+    }
+    handle.addEventListener('pointerup', stop); // no i18n
+    handle.addEventListener('pointercancel', stop); // no i18n
+    box.addEventListener('click', function (event) {
+        if (dragged) {
+            dragged = false;
+            event.stopImmediatePropagation();
+            event.preventDefault();
+        }
+    }, true);
 }
 // core/transport asks for the picked user when it builds the feedback request's parameters
 hooks.feedbackUser = function () {
     return userChoice.anonymous || isEmpty(userChoice.userid) ? null : userChoice;
 };
 
-export { logChoice, userChoice, wireDrag, wireLogControls, wireUserPicker };
+export { chooseUserForSend, logChoice, userChoice, wireDrag, wireLogControls, wireTimerDrag, wireUserPicker };

package/dist/esm/feedback/index.d.ts

@@ -1,8 +1,9 @@
-import { feedbackClose as feedbackCloseImpl } from './ui.js';
 import type { AppticsFeedbackApi } from '../types.js';
-export declare const feedbackOpen: AppticsFeedbackApi["feedbackOpen"];
-export declare const feedbackClose: typeof feedbackCloseImpl;
-/** Resolves once the feedback is sent; rejects when it wasn't (SDK not started, offline, refused). */
-export declare const sendFeedback: AppticsFeedbackApi["sendFeedback"];
-declare const feedback: AppticsFeedbackApi;
-export default feedback;
+export type { FeedbackOpenOptions, SendFeedbackOptions } from '../types.js';
+/**
+ * Android's AppticsFeedback: the form, sending feedback without it, and the context recorded for
+ * the next one. Every feedback call, addFeedbackLog and addDiagnosticsInfo included, is here and
+ * only here: the main entry has no AppticsFeedback.
+ */
+export declare const AppticsFeedback: AppticsFeedbackApi;
+export default AppticsFeedback;

package/dist/esm/feedback/index.js

@@ -1,30 +1,51 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
-import { guard } from '../core/guard.js';
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { forward, guard } from '../core/guard.js';
+import { AP_FEEDBACK_TYPE } from '../core/constants.js';
 import { Console } from '../core/logger.js';
 import { ready } from '../lifecycle.js';
-import { sendFeedback as sendFeedback$1, feedbackClose as feedbackClose$1, feedbackOpen as feedbackOpen$1 } from './ui.js';
+import { setFeedbackTheme, sendFeedback, feedbackFormClose, feedbackFormOpen } from './ui.js';
+import { addDiagnosticsInfo, addFeedbackLog } from './logs.js';
 
 /**
  * Optional feedback modal, shipped as its own entry point:
- *   import { feedbackOpen } from '@zoho_apptics/apptics-js-sdk/feedback';
- *   import '@zoho_apptics/apptics-js-sdk/style.css';
+ *   import { AppticsFeedback } from '@zoho_apptics/apptics-js-sdk/feedback';
+ *   AppticsFeedback.feedbackFormOpen();
  * Apps that never import it don't pay for the modal or its markup.
  * The <script> build includes it, so snippet users are unaffected.
  */
-const feedbackOpen = guard('feedbackOpen', feedbackOpen$1); // no i18n
-const feedbackClose = guard('feedbackClose', feedbackClose$1); // no i18n
+const feedbackFormOpenGuarded = guard('AppticsFeedback.feedbackFormOpen', feedbackFormOpen); // no i18n
+const feedbackFormCloseGuarded = guard('AppticsFeedback.feedbackFormClose', feedbackFormClose); // no i18n
+const addFeedbackLogGuarded = guard('AppticsFeedback.addFeedbackLog', addFeedbackLog); // no i18n
+const addDiagnosticsInfoGuarded = guard('AppticsFeedback.addDiagnosticsInfo', addDiagnosticsInfo); // no i18n
+const setFeedbackThemeGuarded = guard('AppticsFeedback.setFeedbackTheme', setFeedbackTheme); // no i18n
 /** Resolves once the feedback is sent; rejects when it wasn't (SDK not started, offline, refused). */
-const sendFeedback = guard('sendFeedback', function (...args) {
+const sendFeedbackGuarded = guard('AppticsFeedback.sendFeedback', function (...args) {
     return ready().then(function (started) {
         if (!started) {
-            throw new Error('apptics.sendFeedback: not sent, the SDK has not started; call init() first'); // no i18n
+            throw new Error('AppticsFeedback.sendFeedback: not sent, the SDK has not started; call Apptics.init() first'); // no i18n
         }
-        return sendFeedback$1(...args);
+        return sendFeedback(...args);
     }).catch(function (err) {
-        Console.error('apptics.sendFeedback failed:', err); // no i18n
+        Console.error('AppticsFeedback.sendFeedback failed:', err); // no i18n
         throw err;
     });
 });
-const feedback = { feedbackOpen, feedbackClose, sendFeedback };
+/* each call a function of its own, with the parameter names the console shows (see forward) */
+/**
+ * Android's AppticsFeedback: the form, sending feedback without it, and the context recorded for
+ * the next one. Every feedback call, addFeedbackLog and addDiagnosticsInfo included, is here and
+ * only here: the main entry has no AppticsFeedback.
+ */
+const AppticsFeedback = {
+    /** The feedback types: BUG, FEEDBACK, HELP, REPORT. */
+    AP_FEEDBACK_TYPE: AP_FEEDBACK_TYPE,
+    feedbackFormOpen: function feedbackFormOpen(options) { return forward(feedbackFormOpenGuarded, arguments); },
+    feedbackFormClose: function feedbackFormClose() { return forward(feedbackFormCloseGuarded, arguments); },
+    sendFeedback: function sendFeedback(options) { return forward(sendFeedbackGuarded, arguments); },
+    addFeedbackLog: function addFeedbackLog(message) { return forward(addFeedbackLogGuarded, arguments); },
+    addDiagnosticsInfo: function addDiagnosticsInfo(heading, key, value) { return forward(addDiagnosticsInfoGuarded, arguments); },
+    /** The form's theme from now on, and of a form open now: 'light', 'dark' or 'auto'. */
+    setFeedbackTheme: function setFeedbackTheme(theme) { return forward(setFeedbackThemeGuarded, arguments); },
+};
 
-export { feedback as default, feedbackClose, feedbackOpen, sendFeedback };
+export { AppticsFeedback, AppticsFeedback as default };

package/dist/esm/feedback/logs.d.ts

@@ -15,26 +15,28 @@ export declare function trimStoredLogs(): Promise<void>;
  */
 export declare function addFeedbackLog(message: string): void;
 /**
- * Records a diagnostics key/value under a heading, sent inside dyninfo.txt.
- * Entries sharing a heading are grouped together in the file.
+ * Records a diagnostics entry, `value` under `key` in the `heading` block of dyninfo.txt. All three
+ * are required: an entry without a value says nothing, so it is refused and the console says why.
+ * A value of 0 or false is a value.
  */
-export declare function addDiagnosticsInfo(heading: string, key: string, value?: unknown): void;
+export declare function addDiagnosticsInfo(heading: string, key: string, value: unknown): void;
 /** Removes every stored entry. */
 export declare function clearFeedbackLogs(): Promise<void>;
 /** Removes the entries a submission carried, by the ids the rendered files reported. */
-export declare function log_transactions_remove(sentIds: string[]): Promise<void>;
+export declare function feedbacklog_transactions_remove(sentIds: string[]): Promise<void>;
 /** feedbacklog.txt from the stored log lines, or null when there are none. */
 export declare function toLogFile(): Promise<RenderedFile | null>;
-/** The log lines as the file would carry them, for showing in the modal before sending. */
+/**
+ * The log lines for showing in the modal before sending, each time in the visitor's local zone.
+ * The file that is sent (toLogFile) keeps the ISO 8601 UTC stamps, so the server and anything
+ * that parses it are unaffected.
+ */
 export declare function logText(): Promise<string>;
-/** The diagnostics entries as dyninfo.txt would carry them, without the device info block. */
+/** The diagnostics entries as dyninfo.txt carries them. */
 export declare function diagnosticsText(): Promise<string>;
 /** True when any log line is waiting, so the modal knows whether to offer the toggle. */
 export declare function hasLogLines(): Promise<boolean>;
-/**
- * dyninfo.txt: the stored diagnostics entries followed by a [Device Info] block holding
- * `deviceInfo`. Returns null only when there is nothing at all to put in it.
- */
-export declare function toDyninfoFile(deviceInfo: string | null): Promise<RenderedFile | null>;
+/** dyninfo.txt: the stored diagnostics entries. Returns null when there are none. */
+export declare function toDyninfoFile(): Promise<RenderedFile | null>;
 /** True when any diagnostics entry is waiting, so a submission knows to send dyninfo unasked. */
 export declare function hasDiagnostics(): Promise<boolean>;

package/dist/esm/feedback/logs.js

@@ -1,6 +1,7 @@
-/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta | (c) Zoho Corporation Private Limited | see LICENSE */
-import { Console } from '../core/logger.js';
-import { log_transactions } from '../core/storage.js';
+/*! @zoho_apptics/apptics-js-sdk v2.0.0-beta.2 | (c) Zoho Corporation Private Limited | see LICENSE */
+import { warnAlways, Console } from '../core/logger.js';
+import { FEEDBACK_LOG, FEEDBACK_DIAGNOSTICS } from '../core/db.js';
+import { feedbacklog_transactions } from '../core/storage.js';
 import { isExpired } from '../core/state.js';
 import { nowMs } from '../core/utils.js';
 
@@ -24,18 +25,19 @@ const MAX_LOG_FILE_SIZE = 2 * 1024 * 1024;
 const TRIM_DELAY_MS = 2000;
 const LOG_FILE_NAME = 'feedbacklog.txt'; // no i18n
 const DYNINFO_FILE_NAME = 'dyninfo.txt'; // no i18n
-const LOG = 'log'; // no i18n
-const DIAGNOSTICS = 'diagnostics'; // no i18n
+// the types the entries are stored under (2.0.0-beta and 1.x said log and diagnostics)
+const LOG = FEEDBACK_LOG;
+const DIAGNOSTICS = FEEDBACK_DIAGNOSTICS;
 let trimScheduled = false;
 /** Drops the oldest entries once the store is over MAX_ENTRIES. */
 function trimStoredLogs() {
-    return log_transactions.all().then(function (items) {
+    return feedbacklog_transactions.all().then(function (items) {
         const excess = items.length - MAX_ENTRIES;
         if (excess <= 0) {
             return undefined;
         }
         Console.warn('apptics: dropping ' + excess + ' oldest feedback log entries (cap is ' + MAX_ENTRIES + ')'); // no i18n
-        return log_transactions.remove(items.slice(0, excess));
+        return feedbacklog_transactions.remove(items.slice(0, excess));
     });
 }
 /** One trim per burst of adds, so a chatty app pays for one pass over the store, not one per line. */
@@ -50,7 +52,7 @@ function scheduleTrim() {
     }, TRIM_DELAY_MS);
 }
 function store(item) {
-    log_transactions.add(item);
+    feedbacklog_transactions.add(item);
     scheduleTrim();
 }
 function truncate(text) {
@@ -70,11 +72,30 @@ function addFeedbackLog(message) {
  * Records a diagnostics key/value under a heading, sent inside dyninfo.txt.
  * Entries sharing a heading are grouped together in the file.
  */
+/** Messages already printed, so a call repeated in a loop says so once. */
+const refusedSaid = {};
+function refuse(message) {
+    if (!refusedSaid[message]) {
+        refusedSaid[message] = true;
+        warnAlways('AppticsFeedback.addDiagnosticsInfo: ' + message + ', so the entry is not recorded'); // no i18n
+    }
+}
+/**
+ * Records a diagnostics entry, `value` under `key` in the `heading` block of dyninfo.txt. All three
+ * are required: an entry without a value says nothing, so it is refused and the console says why.
+ * A value of 0 or false is a value.
+ */
 function addDiagnosticsInfo(heading, key, value) {
     if (typeof heading !== 'string' || heading.length === 0) { // no i18n
+        refuse('a heading is required');
         return;
     }
     if (typeof key !== 'string' || key.length === 0) { // no i18n
+        refuse('a key is required');
+        return;
+    }
+    if (value === undefined || value === null || value === '') { // no i18n
+        refuse('a value is required for "' + heading + '" / "' + key + '"');
         return;
     }
     store({
@@ -82,16 +103,16 @@ function addDiagnosticsInfo(heading, key, value) {
         happenedat: nowMs(),
         heading: heading,
         key: key,
-        value: truncate(String(value === undefined ? '' : value)), // no i18n
+        value: truncate(String(value)),
     });
 }
 /** Removes the entries a submission carried, by the ids the rendered files reported. */
-function log_transactions_remove(sentIds) {
-    return log_transactions.remove(sentIds.map(function (id) { return { id: id }; }));
+function feedbacklog_transactions_remove(sentIds) {
+    return feedbacklog_transactions.remove(sentIds.map(function (id) { return { id: id }; }));
 }
 /** Entries of one type, oldest first, skipping any that have passed batch_request_timeout. */
 function entriesOfType(type) {
-    return log_transactions.all().then(function (items) {
+    return feedbacklog_transactions.all().then(function (items) {
         return items.filter(function (item) {
             return item.type === type && !isExpired(item.happenedat);
         });
@@ -145,11 +166,29 @@ function toLogFile() {
         return asFile(LOG_FILE_NAME, renderLogLines(items), items);
     });
 }
-/** The log lines as the file would carry them, for showing in the modal before sending. */
+/** `16 Oct 2026, 11:53:48 PM`: a log line's time in the visitor's own zone, for the viewer. */
+function readableStamp(item) {
+    var iso = stamp(item);
+    var d = new Date(iso);
+    if (isNaN(d.getTime())) {
+        return iso;
+    }
+    return d.toLocaleDateString(undefined, { day: '2-digit', month: 'short', year: 'numeric' }) + ', ' + // no i18n
+        d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit', second: '2-digit' }); // no i18n
+}
+/**
+ * The log lines for showing in the modal before sending, each time in the visitor's local zone.
+ * The file that is sent (toLogFile) keeps the ISO 8601 UTC stamps, so the server and anything
+ * that parses it are unaffected.
+ */
 function logText() {
-    return entriesOfType(LOG).then(renderLogLines);
+    return entriesOfType(LOG).then(function (items) {
+        return items.map(function (item) {
+            return '[' + readableStamp(item) + '] ' + item.message; // no i18n
+        }).join('\n'); // no i18n
+    });
 }
-/** The diagnostics entries as dyninfo.txt would carry them, without the device info block. */
+/** The diagnostics entries as dyninfo.txt carries them. */
 function diagnosticsText() {
     return entriesOfType(DIAGNOSTICS).then(groupDiagnostics);
 }
@@ -159,23 +198,13 @@ function hasLogLines() {
         return items.length > 0;
     });
 }
-/**
- * dyninfo.txt: the stored diagnostics entries followed by a [Device Info] block holding
- * `deviceInfo`. Returns null only when there is nothing at all to put in it.
- */
-function toDyninfoFile(deviceInfo) {
+/** dyninfo.txt: the stored diagnostics entries. Returns null when there are none. */
+function toDyninfoFile() {
     return entriesOfType(DIAGNOSTICS).then(function (items) {
-        const blocks = [];
-        if (items.length > 0) {
-            blocks.push(groupDiagnostics(items));
-        }
-        if (deviceInfo) {
-            blocks.push('[Device Info]\n' + deviceInfo); // no i18n
-        }
-        if (blocks.length === 0) {
+        if (items.length === 0) {
             return null;
         }
-        return asFile(DYNINFO_FILE_NAME, blocks.join('\n\n'), items); // no i18n
+        return asFile(DYNINFO_FILE_NAME, groupDiagnostics(items), items);
     });
 }
 /** True when any diagnostics entry is waiting, so a submission knows to send dyninfo unasked. */
@@ -185,4 +214,4 @@ function hasDiagnostics() {
     });
 }
 
-export { DYNINFO_FILE_NAME, LOG_FILE_NAME, MAX_LOG_FILE_SIZE, addDiagnosticsInfo, addFeedbackLog, diagnosticsText, hasDiagnostics, hasLogLines, logText, log_transactions_remove, toDyninfoFile, toLogFile, trimStoredLogs };
+export { DYNINFO_FILE_NAME, LOG_FILE_NAME, MAX_LOG_FILE_SIZE, addDiagnosticsInfo, addFeedbackLog, diagnosticsText, feedbacklog_transactions_remove, hasDiagnostics, hasLogLines, logText, toDyninfoFile, toLogFile, trimStoredLogs };

package/dist/esm/feedback/quartz.d.ts

@@ -0,0 +1,18 @@
+/** quartz_domain as a recording host: zoho.com → https://quartz.zoho.com. '' when it isn't a domain. */
+export declare function recordingDomain(domain: string): string;
+/**
+ * The Quartz script for an app whose getsdkconfig answer carries no quartz_cdn_url, chosen by
+ * the serviceUrl: a localzoho server's apps load it from Zoho's local CDN, every other app from
+ * the public one.
+ */
+export declare function defaultQuartzScriptUrl(serviceUrl: string): string;
+/** The script to load: quartz_cdn_url when getsdkconfig gave one, else the CDN the serviceUrl points to. */
+export declare function quartzScriptSource(cdnUrl: string, serviceUrl: string): string;
+/** The url to load, or '' when it isn't an https url on a Zoho host. */
+export declare function quartzScriptUrl(url: string): string;
+/**
+ * Makes Quartz available: resolves true once it is on the page, false when it can't be (no url,
+ * a url that isn't allowed, or a script that failed to load). Adds the script once; every caller
+ * waits on the same load, and a failed one may be tried again on the next open.
+ */
+export declare function loadQuartz(url: string): Promise<boolean>;