@valbuild/react 0.148.2 → 0.148.4

package/analytics/dist/valbuild-react-analytics.worker.esm.js

@@ -0,0 +1,232 @@
+import { _ as _toConsumableArray } from '../../dist/toConsumableArray-5335b4b0.worker.esm.js';
+import { _ as _slicedToArray } from '../../dist/slicedToArray-8b1a55e5.worker.esm.js';
+import { _ as _createForOfIteratorHelper } from '../../dist/createForOfIteratorHelper-73fe9a1a.worker.esm.js';
+
+/**
+ * The analytics wire format, version 1: what the browser sends to
+ * `POST /api/val/analytics`. See `docs/plans/analytics.md`, "Wire format".
+ *
+ * Nothing in this directory may import `@valbuild/core`, `@valbuild/shared`
+ * or zod: this is code every visitor of a site downloads, and those three are
+ * most of the weight Val already puts on a page (`client-bundle-weight.md`).
+ * `imports.test.ts` keeps it so. The zod schema the server parses this with
+ * is `AnalyticsBeacon` in `@valbuild/shared/internal`, and `beacon.test.ts`
+ * checks the two agree.
+ */
+
+/** What only the first beacon of a page view carries. Its presence IS the page view. */
+
+/** Module file path → module paths (the part of a source path after `?p=`). */
+
+/**
+ * The receiver rejects a beacon above these (`AnalyticsBeacon` in
+ * `@valbuild/shared/internal` repeats them), so the sender never sends more:
+ * it cuts or drops what is longer, and splits what is larger.
+ */
+var MAX_PATHS_PER_BEACON = 200;
+var MAX_ROUTE_LENGTH = 512;
+var MAX_UTM_LENGTH = 100;
+var MAX_CV_LENGTH = 128;
+var MAX_MODULE_FILE_PATH_LENGTH = 512;
+var MAX_MODULE_PATH_LENGTH = 1024;
+/**
+ * A beacon's size in bytes of JSON, below the 16 KB Val's hosting accepts --
+ * 200 long router keys are about 18 KB. `sendBeacon` itself takes 64 KB.
+ */
+var MAX_BEACON_BYTES = 12000;
+var MODULE_FILE_PATH_SEP = "?p=";
+
+/** Splits a source path into its module file path and its module path. */
+function splitSourcePath(sourcePath) {
+  var at = sourcePath.indexOf(MODULE_FILE_PATH_SEP);
+  if (at === -1) {
+    return [sourcePath, ""];
+  }
+  return [sourcePath.slice(0, at), sourcePath.slice(at + MODULE_FILE_PATH_SEP.length)];
+}
+
+/**
+ * The beacons that carry `rendered` and `viewed`: at most
+ * `MAX_PATHS_PER_BEACON` paths and about `MAX_BEACON_BYTES` each. `view`, when
+ * given, goes in the first. Returns none when there is nothing to say.
+ *
+ * A path longer than the receiver takes is dropped rather than cut: half a
+ * path names some other content, or none.
+ */
+function buildBeacons(args) {
+  var _args$cv;
+  var counted = function counted(kind, sourcePath) {
+    var _splitSourcePath = splitSourcePath(sourcePath),
+      _splitSourcePath2 = _slicedToArray(_splitSourcePath, 2),
+      moduleFilePath = _splitSourcePath2[0],
+      modulePath = _splitSourcePath2[1];
+    if (moduleFilePath.length > MAX_MODULE_FILE_PATH_LENGTH || modulePath.length > MAX_MODULE_PATH_LENGTH) {
+      return [];
+    }
+    return [{
+      kind: kind,
+      moduleFilePath: moduleFilePath,
+      modulePath: modulePath
+    }];
+  };
+  var all = [].concat(_toConsumableArray(args.rendered.flatMap(function (path) {
+    return counted("rendered", path);
+  })), _toConsumableArray(args.viewed.flatMap(function (path) {
+    return counted("viewed", path);
+  })));
+  if (all.length === 0 && !args.view) {
+    return [];
+  }
+  var cv = (_args$cv = args.cv) === null || _args$cv === void 0 ? void 0 : _args$cv.slice(0, MAX_CV_LENGTH);
+  var empty = function empty(withView) {
+    var beacon = {
+      v: 1,
+      route: args.route,
+      rendered: {},
+      viewed: {}
+    };
+    if (cv) {
+      beacon.cv = cv;
+    }
+    if (withView && args.view) {
+      beacon.view = args.view;
+    }
+    return beacon;
+  };
+  var beacons = [];
+  var beacon = empty(true);
+  var paths = 0;
+  var bytes = byteLength(JSON.stringify(beacon));
+  // What adding a path costs: the path and a comma, and a new key when its
+  // module is not in this beacon yet. An estimate in UTF-8 bytes, close
+  // enough to keep well under the limit.
+  var costOf = function costOf(path) {
+    return byteLength(JSON.stringify(path.modulePath)) + 1 + (beacon[path.kind][path.moduleFilePath] ? 0 : byteLength(JSON.stringify(path.moduleFilePath)) + 4);
+  };
+  var _iterator2 = _createForOfIteratorHelper(all),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _beacon$path$kind, _path$moduleFilePath, _beacon$path$kind$_pa;
+      var path = _step2.value;
+      var cost = costOf(path);
+      if (paths > 0 && (paths === MAX_PATHS_PER_BEACON || bytes + cost > MAX_BEACON_BYTES)) {
+        beacons.push(beacon);
+        beacon = empty(false);
+        paths = 0;
+        bytes = byteLength(JSON.stringify(beacon));
+        cost = costOf(path);
+      }
+      ((_beacon$path$kind$_pa = (_beacon$path$kind = beacon[path.kind])[_path$moduleFilePath = path.moduleFilePath]) !== null && _beacon$path$kind$_pa !== void 0 ? _beacon$path$kind$_pa : _beacon$path$kind[_path$moduleFilePath] = []).push(path.modulePath);
+      paths += 1;
+      bytes += cost;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  beacons.push(beacon);
+  return beacons;
+}
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+
+/**
+ * The source paths in a `data-val-path` attribute.
+ *
+ * One element can show several pieces of content, and `attrs()` and
+ * `autoTagJSX` join their paths with commas. Core's `splitJoinedSourcePaths`
+ * splits on every comma, which cuts a path whose record key holds one
+ * (`"/blog/a,b"`). This splits only on commas outside the JSON strings a
+ * module path is made of, so it agrees with core wherever core is right and
+ * keeps such a path whole. It is here rather than imported because nothing in
+ * this directory may import core -- see `beacon.ts`.
+ */
+function splitValPaths(attribute) {
+  if (!attribute) {
+    return [];
+  }
+  var paths = [];
+  var current = "";
+  var inString = false;
+  var escaped = false;
+  var _iterator = _createForOfIteratorHelper(attribute),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _char = _step.value;
+      if (inString) {
+        current += _char;
+        if (escaped) {
+          escaped = false;
+        } else if (_char === "\\") {
+          escaped = true;
+        } else if (_char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (_char === '"') {
+        inString = true;
+        current += _char;
+        continue;
+      }
+      if (_char === ",") {
+        if (current) {
+          paths.push(current);
+        }
+        current = "";
+        continue;
+      }
+      current += _char;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (current) {
+    paths.push(current);
+  }
+  return paths;
+}
+
+/** Every 5%, so an element far taller than the screen still crosses one. */
+Array.from({
+  length: 21
+}, function (_, i) {
+  return i / 20;
+});
+
+/**
+ * Counts which content a visitor's page shows, and sends it.
+ *
+ * - **Rendered**: an element with a `data-val-path` is in the document.
+ * - **Viewed**: one is at least half visible -- or covers at least half the
+ *   viewport, for an element taller than it -- for `viewedAfterMs` without a
+ *   break, while the page is visible.
+ *
+ * Each path counts at most once of each per page view. A page view starts with
+ * the page and with every client-side navigation to another pathname; content
+ * still on screen after one (a header, a footer) counts again for the new one,
+ * because it was rendered on it.
+ *
+ * Returns null where it does nothing: on the server, and for an automated
+ * browser (`navigator.webdriver`). The caller decides the rest -- draft mode,
+ * the Studio's canvas and an editor browsing with Val enabled all count
+ * nothing, and the provider does not start it for them.
+ *
+ * A page the browser PRERENDERS (speculation rules, the address bar's guess
+ * at where the visitor is going) is hydrated with nobody looking, and may
+ * never be looked at: nothing starts until it is shown, and nothing at all
+ * if it never is.
+ */
+function startValAnalytics() {
+  {
+    return null;
+  }
+}
+
+export { MAX_PATHS_PER_BEACON, MAX_ROUTE_LENGTH, MAX_UTM_LENGTH, buildBeacons, splitValPaths, startValAnalytics };

package/analytics/package.json

@@ -0,0 +1,7 @@
+{
+  "main": "dist/valbuild-react-analytics.cjs.js",
+  "module": "dist/valbuild-react-analytics.esm.js",
+  "browser": {
+    "./dist/valbuild-react-analytics.esm.js": "./dist/valbuild-react-analytics.browser.esm.js"
+  }
+}

package/dist/createForOfIteratorHelper-69c4a419.esm.js

@@ -0,0 +1,52 @@
+import { a as _unsupportedIterableToArray } from './slicedToArray-3d4c6640.esm.js';
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+export { _createForOfIteratorHelper as _ };

package/dist/createForOfIteratorHelper-6f9dc6fa.cjs.prod.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var slicedToArray = require('./slicedToArray-64c83d56.cjs.prod.js');
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = slicedToArray._unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;

package/dist/createForOfIteratorHelper-73fe9a1a.worker.esm.js

@@ -0,0 +1,52 @@
+import { a as _unsupportedIterableToArray } from './slicedToArray-8b1a55e5.worker.esm.js';
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+export { _createForOfIteratorHelper as _ };

package/dist/createForOfIteratorHelper-8a871dc3.cjs.dev.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var slicedToArray = require('./slicedToArray-387314c6.cjs.dev.js');
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = slicedToArray._unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;

package/dist/createForOfIteratorHelper-c0be3691.browser.esm.js

@@ -0,0 +1,52 @@
+import { a as _unsupportedIterableToArray } from './slicedToArray-8f9b0d84.browser.esm.js';
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+export { _createForOfIteratorHelper as _ };

package/dist/declarations/src/analytics/beacon.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The analytics wire format, version 1: what the browser sends to
+ * `POST /api/val/analytics`. See `docs/plans/analytics.md`, "Wire format".
+ *
+ * Nothing in this directory may import `@valbuild/core`, `@valbuild/shared`
+ * or zod: this is code every visitor of a site downloads, and those three are
+ * most of the weight Val already puts on a page (`client-bundle-weight.md`).
+ * `imports.test.ts` keeps it so. The zod schema the server parses this with
+ * is `AnalyticsBeacon` in `@valbuild/shared/internal`, and `beacon.test.ts`
+ * checks the two agree.
+ */
+export type AnalyticsDevice = "phone" | "tablet" | "desktop";
+export type AnalyticsUtm = {
+    source?: string;
+    medium?: string;
+    campaign?: string;
+};
+/** What only the first beacon of a page view carries. Its presence IS the page view. */
+export type AnalyticsPageView = {
+    /** `document.referrer`'s host, only when it is another site. */
+    ref?: string;
+    utm?: AnalyticsUtm;
+    device: AnalyticsDevice;
+};
+/** Module file path → module paths (the part of a source path after `?p=`). */
+export type AnalyticsPaths = Record<string, string[]>;
+export type AnalyticsBeacon = {
+    v: 1;
+    /** `location.pathname`, never the query or the hash. */
+    route: string;
+    /** The content version the page was rendered from, when the page knows it. */
+    cv?: string;
+    view?: AnalyticsPageView;
+    rendered: AnalyticsPaths;
+    viewed: AnalyticsPaths;
+};
+/**
+ * The receiver rejects a beacon above these (`AnalyticsBeacon` in
+ * `@valbuild/shared/internal` repeats them), so the sender never sends more:
+ * it cuts or drops what is longer, and splits what is larger.
+ */
+export declare const MAX_PATHS_PER_BEACON = 200;
+export declare const MAX_ROUTE_LENGTH = 512;
+export declare const MAX_UTM_LENGTH = 100;
+/** A host name is at most 253 characters (RFC 1035). */
+export declare const MAX_REF_LENGTH = 253;
+export declare const MAX_CV_LENGTH = 128;
+export declare const MAX_MODULE_FILE_PATH_LENGTH = 512;
+export declare const MAX_MODULE_PATH_LENGTH = 1024;
+/**
+ * A beacon's size in bytes of JSON, below the 16 KB Val's hosting accepts --
+ * 200 long router keys are about 18 KB. `sendBeacon` itself takes 64 KB.
+ */
+export declare const MAX_BEACON_BYTES = 12000;
+/** Phone below 640 px of viewport width, tablet below 1024, desktop above. */
+export declare function deviceOf(viewportWidth: number): AnalyticsDevice;
+/**
+ * The referrer's host, when it is another site -- never its path or query,
+ * which can carry anything. A referrer from this site is navigation within it,
+ * not a source.
+ */
+export declare function referrerHostOf(referrer: string, ownHost: string): string | undefined;
+/** `utm_source`, `utm_medium` and `utm_campaign`, and no other parameter. */
+export declare function utmOf(search: string): AnalyticsUtm | undefined;
+export declare function routeOf(pathname: string): string;
+/**
+ * The beacons that carry `rendered` and `viewed`: at most
+ * `MAX_PATHS_PER_BEACON` paths and about `MAX_BEACON_BYTES` each. `view`, when
+ * given, goes in the first. Returns none when there is nothing to say.
+ *
+ * A path longer than the receiver takes is dropped rather than cut: half a
+ * path names some other content, or none.
+ */
+export declare function buildBeacons(args: {
+    route: string;
+    cv?: string;
+    view?: AnalyticsPageView;
+    rendered: readonly string[];
+    viewed: readonly string[];
+}): AnalyticsBeacon[];

package/dist/declarations/src/analytics/index.d.ts

@@ -0,0 +1,3 @@
+export { startValAnalytics, type ValAnalyticsTracker, type ValAnalyticsOptions, } from "./tracker.js";
+export { buildBeacons, type AnalyticsBeacon, type AnalyticsDevice, type AnalyticsPageView, type AnalyticsPaths, type AnalyticsUtm, MAX_PATHS_PER_BEACON, MAX_ROUTE_LENGTH, MAX_UTM_LENGTH, } from "./beacon.js";
+export { splitValPaths } from "./splitValPaths.js";

package/dist/declarations/src/analytics/splitValPaths.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The source paths in a `data-val-path` attribute.
+ *
+ * One element can show several pieces of content, and `attrs()` and
+ * `autoTagJSX` join their paths with commas. Core's `splitJoinedSourcePaths`
+ * splits on every comma, which cuts a path whose record key holds one
+ * (`"/blog/a,b"`). This splits only on commas outside the JSON strings a
+ * module path is made of, so it agrees with core wherever core is right and
+ * keeps such a path whole. It is here rather than imported because nothing in
+ * this directory may import core -- see `beacon.ts`.
+ */
+export declare function splitValPaths(attribute: string | null): string[];

package/dist/declarations/src/analytics/tracker.d.ts

@@ -0,0 +1,64 @@
+export type ValAnalyticsOptions = {
+    /** Where beacons go. Default `/api/val/analytics`, on the site's own origin. */
+    endpoint?: string;
+    /** The content version the page was rendered from, sent as `cv`. */
+    contentVersion?: string;
+    /** How long after a page view starts its first beacon goes. Default 3 s. */
+    firstSendAfterMs?: number;
+    /** How long an element must stay on screen to count as viewed. Default 1 s. */
+    viewedAfterMs?: number;
+    /** How many new paths make a beacon worth sending before the page is left. Default 50. */
+    sendWhenPending?: number;
+    /** The shortest time between two of those. Default 15 s. */
+    minSendIntervalMs?: number;
+    /**
+     * The pathname the page was rendered and hydrated at. When the visitor is
+     * somewhere else by the time this starts, they navigated in between, and
+     * that page is sent as a page view of its own. Without it, the URL the
+     * document was loaded at stands in -- which also differs after a redirect
+     * or a trailing slash the router normalised, so a caller that knows should
+     * say.
+     */
+    landingPath?: string;
+    /**
+     * The route a pathname is a page of, as the app names it: `/blogs/$slug`
+     * for `/blogs/a-post`. What is sent, so a path that holds something about
+     * one visitor -- an order number, a token, an email address -- is never
+     * stored as if it were a page of the site. Without it the pathname is sent
+     * as it is, so a caller that knows its routes should say.
+     *
+     * A page view is still a change of PATHNAME: `/blogs/a` to `/blogs/b` is a
+     * new one, of the same route.
+     */
+    routeFor?: (pathname: string) => string;
+};
+export type ValAnalyticsTracker = {
+    /** Sends what is waiting now. */
+    flush(): void;
+    /** Sends what is waiting, then stops counting and restores everything it patched. */
+    stop(): void;
+};
+/**
+ * Counts which content a visitor's page shows, and sends it.
+ *
+ * - **Rendered**: an element with a `data-val-path` is in the document.
+ * - **Viewed**: one is at least half visible -- or covers at least half the
+ *   viewport, for an element taller than it -- for `viewedAfterMs` without a
+ *   break, while the page is visible.
+ *
+ * Each path counts at most once of each per page view. A page view starts with
+ * the page and with every client-side navigation to another pathname; content
+ * still on screen after one (a header, a footer) counts again for the new one,
+ * because it was rendered on it.
+ *
+ * Returns null where it does nothing: on the server, and for an automated
+ * browser (`navigator.webdriver`). The caller decides the rest -- draft mode,
+ * the Studio's canvas and an editor browsing with Val enabled all count
+ * nothing, and the provider does not start it for them.
+ *
+ * A page the browser PRERENDERS (speculation rules, the address bar's guess
+ * at where the visitor is going) is hydrated with nobody looking, and may
+ * never be looked at: nothing starts until it is shown, and nothing at all
+ * if it never is.
+ */
+export declare function startValAnalytics(options?: ValAnalyticsOptions): ValAnalyticsTracker | null;