@byline/host-tanstack-start 4.15.0 → 4.16.0

package/dist/admin-shell/chrome/admin-menu-drawer.d.ts

@@ -6,6 +6,7 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type React from 'react';
-export declare function AdminMenuDrawer({ scheduledPublicationEnabled, }: {
+export declare function AdminMenuDrawer({ analyticsEnabled, scheduledPublicationEnabled, }: {
+    analyticsEnabled?: boolean;
     scheduledPublicationEnabled?: boolean;
 }): React.JSX.Element | null;

package/dist/admin-shell/chrome/admin-menu-drawer.js

@@ -4,9 +4,10 @@ import { ADMIN_ACTIVITY_ABILITIES } from "@byline/admin/admin-activity";
 import { ADMIN_PERMISSIONS_ABILITIES } from "@byline/admin/admin-permissions";
 import { ADMIN_ROLES_ABILITIES } from "@byline/admin/admin-roles";
 import { ADMIN_USERS_ABILITIES } from "@byline/admin/admin-users";
+import { ANALYTICS_ABILITIES } from "@byline/admin/analytics";
 import { collectionAbilityKey, getAdminConfig } from "@byline/core";
 import { useTranslation } from "@byline/i18n/react";
-import { ActivityIcon, CalendarIcon, HomeIcon, RolesIcon, SettingsSlidersIcon, Tooltip, UserIcon, UsersIcon } from "@byline/ui/react";
+import { ActivityIcon, AnalyticsIcon, CalendarIcon, HomeIcon, RolesIcon, SettingsSlidersIcon, Tooltip, UserIcon, UsersIcon } from "@byline/ui/react";
 import clsx from "clsx";
 import { useSwipeable } from "react-swipeable";
 import { useAbilities } from "../../integrations/abilities.js";
@@ -46,7 +47,7 @@ function MenuItem({ to, label, icon, pathname, compact }) {
         })
     });
 }
-function AdminMenuDrawer({ scheduledPublicationEnabled = false }) {
+function AdminMenuDrawer({ analyticsEnabled = false, scheduledPublicationEnabled = false }) {
     const pathname = useRouterState({
         select: (s)=>s.location.pathname
     });
@@ -57,6 +58,7 @@ function AdminMenuDrawer({ scheduledPublicationEnabled = false }) {
     const canReadRoles = has(ADMIN_ROLES_ABILITIES.read);
     const canReadPermissions = has(ADMIN_PERMISSIONS_ABILITIES.read);
     const canReadActivity = has(ADMIN_ACTIVITY_ABILITIES.read);
+    const canReadAnalytics = analyticsEnabled && has(ANALYTICS_ABILITIES.read);
     const canSeeScheduledPublications = scheduledPublicationEnabled && getAdminConfig().collections.some((collection)=>has(collectionAbilityKey(collection.path, 'changeStatus')) && has(collectionAbilityKey(collection.path, 'publish')));
     const showAdminSection = canReadUsers || canReadRoles || canReadPermissions || canReadActivity;
     const handlers = useSwipeable({
@@ -106,6 +108,16 @@ function AdminMenuDrawer({ scheduledPublicationEnabled = false }) {
                         pathname: pathname,
                         compact: compact
                     }),
+                    canReadAnalytics && /*#__PURE__*/ jsx(MenuItem, {
+                        to: getAdminRoutePath('analytics'),
+                        label: t('chrome.menu.analytics'),
+                        icon: /*#__PURE__*/ jsx(AnalyticsIcon, {
+                            width: "20px",
+                            height: "20px"
+                        }),
+                        pathname: pathname,
+                        compact: compact
+                    }),
                     showAdminSection && /*#__PURE__*/ jsxs(Fragment, {
                         children: [
                             /*#__PURE__*/ jsx("li", {

package/dist/integrations/analytics-agent.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type React from 'react';
+export interface AnalyticsAgentProps {
+    /** Application-owned same-origin route that receives browser events. */
+    endpoint: string;
+    src?: string;
+    cdnHosts?: readonly string[];
+    downloadExtensions?: readonly string[];
+    ignoredPathPrefixes?: readonly string[];
+    countSearchChanges?: boolean;
+    countHashChanges?: boolean;
+}
+/** Render the standalone script and bridge only committed router locations into it. */
+export declare function AnalyticsAgent({ endpoint, src, cdnHosts, downloadExtensions, ignoredPathPrefixes, countSearchChanges, countHashChanges, }: AnalyticsAgentProps): React.JSX.Element;

package/dist/integrations/analytics-agent.js

@@ -0,0 +1,57 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { useRouterState } from "@tanstack/react-router";
+import { ANALYTICS_NAVIGATION_EVENT, ANALYTICS_STOP_EVENT } from "@byline/analytics-agent";
+let pendingStopTimer;
+function AnalyticsAgent({ endpoint, src = '/b.js', cdnHosts, downloadExtensions, ignoredPathPrefixes, countSearchChanges = false, countHashChanges = false }) {
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx("script", {
+                defer: true,
+                src: src,
+                "data-endpoint": endpoint,
+                "data-cdn-hosts": boundedAttribute(cdnHosts),
+                "data-download-extensions": boundedAttribute(downloadExtensions),
+                "data-ignore-prefixes": boundedAttribute(ignoredPathPrefixes),
+                "data-count-search": countSearchChanges ? 'true' : void 0,
+                "data-count-hash": countHashChanges ? 'true' : void 0
+            }),
+            /*#__PURE__*/ jsx(AnalyticsNavigationBridge, {})
+        ]
+    });
+}
+function AnalyticsNavigationBridge() {
+    const href = useRouterState({
+        select: (state)=>state.location.href
+    });
+    const previousHref = useRef(void 0);
+    useEffect(()=>{
+        const previous = previousHref.current;
+        previousHref.current = href;
+        if (null == previous || previous === href) return;
+        document.dispatchEvent(new CustomEvent(ANALYTICS_NAVIGATION_EVENT, {
+            detail: href
+        }));
+    }, [
+        href
+    ]);
+    useEffect(()=>{
+        if (void 0 !== pendingStopTimer) {
+            window.clearTimeout(pendingStopTimer);
+            pendingStopTimer = void 0;
+        }
+        return ()=>{
+            pendingStopTimer = window.setTimeout(()=>{
+                pendingStopTimer = void 0;
+                document.dispatchEvent(new Event(ANALYTICS_STOP_EVENT));
+            }, 0);
+        };
+    }, []);
+    return null;
+}
+function boundedAttribute(values) {
+    if (null == values || 0 === values.length) return;
+    return values.slice(0, 64).join(',').slice(0, 2048);
+}
+export { AnalyticsAgent };

package/dist/integrations/analytics-events.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { type Analytics } from '@byline/analytics';
+import { type BylineLogger } from '@byline/core';
+export interface AnalyticsEventHandlerOptions {
+    /** Host-owned resolver for deployment-specific, request-scoped network facts. */
+    resolveRequestContext: AnalyticsRequestContextResolver;
+    /** Test/embedding seam; production resolves the registered installation runtime. */
+    analytics?: () => Pick<Analytics, 'ingest'>;
+    /** Test/embedding seam; production resolves the initialized application logger. */
+    logger?: () => Pick<BylineLogger, 'error'>;
+}
+export interface AnalyticsRequestContext {
+    clientIp?: string | null;
+    country?: string | null;
+}
+export type AnalyticsRequestContextResolver = (request: Request) => AnalyticsRequestContext | Promise<AnalyticsRequestContext>;
+export interface LocalAnalyticsRequestContextOptions {
+    /** Resolve the direct peer address from the host runtime, without forwarded headers. */
+    resolveClientIp: (request: Request) => string | null | undefined | Promise<string | null | undefined>;
+    /** Explicit development-only identity for runtimes that expose no peer address. */
+    developmentFallbackClientIp?: string;
+}
+export interface TrustedAnalyticsHeadersOptions {
+    /** Header overwritten by the trusted reverse proxy with the normalized client address. */
+    clientIpHeader: string;
+    /** Optional header overwritten by the trusted edge with an ISO country code. */
+    countryHeader?: string;
+    /** Explicit context or resolver used only when a trusted header is absent. */
+    fallback?: AnalyticsRequestContext | AnalyticsRequestContextResolver;
+}
+/**
+ * Resolve an identity for a server reached directly through a loopback URL.
+ * Both the URL and the direct peer address must be loopback. This is safe for
+ * a directly reached local server. A same-host reverse proxy also appears as
+ * a loopback peer, however, so do not expose this fallback through a public
+ * proxy where a client can select the Host header.
+ */
+export declare function localAnalyticsRequestContext(options: LocalAnalyticsRequestContextOptions): AnalyticsRequestContextResolver;
+/**
+ * Resolve network facts from headers owned and overwritten by a trusted proxy.
+ * This helper does not establish that trust: the deployment must prevent a
+ * client from selecting the configured header values or bypassing the proxy.
+ */
+export declare function trustedAnalyticsHeaders(options: TrustedAnalyticsHeadersOptions): AnalyticsRequestContextResolver;
+export declare function createAnalyticsEventHandler(options: AnalyticsEventHandlerOptions): (request: Request) => Promise<Response>;

package/dist/integrations/analytics-events.js

@@ -0,0 +1,129 @@
+import { ANALYTICS_MAX_BODY_BYTES, getAnalytics } from "@byline/analytics";
+import { getLogger } from "@byline/core";
+function localAnalyticsRequestContext(options) {
+    const developmentFallbackClientIp = null == options.developmentFallbackClientIp ? void 0 : validateFact(options.developmentFallbackClientIp, 'developmentFallbackClientIp', 255);
+    return async (request)=>{
+        const clientIp = await options.resolveClientIp(request);
+        if (isLoopbackHostname(new URL(request.url).hostname) && isLoopbackAddress(clientIp)) return {
+            clientIp: validateFact(clientIp, 'resolved clientIp', 255)
+        };
+        return null == developmentFallbackClientIp ? {} : {
+            clientIp: developmentFallbackClientIp
+        };
+    };
+}
+function trustedAnalyticsHeaders(options) {
+    const clientIpHeader = validateHeaderName(options.clientIpHeader, 'clientIpHeader');
+    const countryHeader = null == options.countryHeader ? void 0 : validateHeaderName(options.countryHeader, 'countryHeader');
+    const fallback = 'function' == typeof options.fallback ? options.fallback : validateFallback(options.fallback);
+    return async (request)=>{
+        const fallbackContext = 'function' == typeof fallback ? validateFallback(await fallback(request)) : fallback;
+        return {
+            clientIp: request.headers.get(clientIpHeader)?.trim() || fallbackContext?.clientIp,
+            country: (null == countryHeader ? null : request.headers.get(countryHeader)?.trim()) || fallbackContext?.country
+        };
+    };
+}
+function createAnalyticsEventHandler(options) {
+    const resolveAnalytics = options.analytics ?? getAnalytics;
+    return async (request)=>{
+        const body = await readBoundedBody(request, ANALYTICS_MAX_BODY_BYTES);
+        try {
+            const requestContext = await options.resolveRequestContext(request);
+            const result = await resolveAnalytics().ingest({
+                method: request.method,
+                body: body ?? new Uint8Array(ANALYTICS_MAX_BODY_BYTES + 1),
+                origin: request.headers.get('origin'),
+                referer: request.headers.get('referer'),
+                userAgent: request.headers.get('user-agent'),
+                secPurpose: request.headers.get('sec-purpose'),
+                xPurpose: request.headers.get('x-purpose'),
+                clientIp: requestContext.clientIp,
+                country: requestContext.country
+            });
+            return analyticsResponse(result.status);
+        } catch (error) {
+            const logger = options.logger?.() ?? getLogger();
+            logger.error({
+                errorCode: safeErrorCode(error)
+            }, '[analytics] event persistence failed');
+            return analyticsResponse(503);
+        }
+    };
+}
+function safeErrorCode(error) {
+    if (null == error || 'object' != typeof error || !('code' in error)) return 'UNKNOWN';
+    const code = error.code;
+    return 'string' == typeof code && /^[a-z0-9_-]{1,64}$/iu.test(code) ? code : 'UNKNOWN';
+}
+function analyticsResponse(status) {
+    return new Response(null, {
+        status,
+        headers: {
+            'cache-control': 'no-store'
+        }
+    });
+}
+async function readBoundedBody(request, limit) {
+    const declaredLength = Number(request.headers.get('content-length'));
+    if (Number.isFinite(declaredLength) && declaredLength > limit) return null;
+    if (null == request.body) return new Uint8Array();
+    const reader = request.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) break;
+            length += value.byteLength;
+            if (length > limit) {
+                await reader.cancel();
+                return null;
+            }
+            chunks.push(value);
+        }
+    } finally{
+        reader.releaseLock();
+    }
+    const body = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks){
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return body;
+}
+function validateHeaderName(value, label) {
+    const normalized = value.trim().toLowerCase();
+    if (!/^[!#$%&'*+.^_`|~0-9a-z-]+$/u.test(normalized)) throw new Error(`analytics ${label} must be a valid HTTP header name`);
+    return normalized;
+}
+function validateFallback(value) {
+    if (null == value) return;
+    return {
+        ...null == value.clientIp ? {} : {
+            clientIp: validateFact(value.clientIp, 'fallback.clientIp', 255)
+        },
+        ...null == value.country ? {} : {
+            country: validateFact(value.country, 'fallback.country', 16)
+        }
+    };
+}
+function validateFact(value, label, maxLength) {
+    const normalized = value.trim();
+    if (0 === normalized.length || normalized.length > maxLength) throw new Error(`analytics ${label} must contain 1 to ${maxLength} characters`);
+    return normalized;
+}
+function isLoopbackHostname(value) {
+    const normalized = stripIpv6Brackets(value.toLowerCase());
+    return 'localhost' === normalized || normalized.endsWith('.localhost') || isLoopbackAddress(normalized);
+}
+function isLoopbackAddress(value) {
+    if (null == value) return false;
+    const normalized = stripIpv6Brackets(value.trim().toLowerCase());
+    return '::1' === normalized || /^127(?:\.\d{1,3}){3}$/u.test(normalized) || /^::ffff:127(?:\.\d{1,3}){3}$/u.test(normalized);
+}
+function stripIpv6Brackets(value) {
+    return value.startsWith('[') && value.endsWith(']') ? value.slice(1, -1) : value;
+}
+export { createAnalyticsEventHandler, localAnalyticsRequestContext, trustedAnalyticsHeaders };

package/dist/integrations/serve-analytics-agent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export declare function serveAnalyticsAgent(): Response;

package/dist/integrations/serve-analytics-agent.js

@@ -0,0 +1,11 @@
+import { ANALYTICS_AGENT_SOURCE } from "@byline/analytics-agent/source";
+function serveAnalyticsAgent() {
+    return new Response(ANALYTICS_AGENT_SOURCE, {
+        headers: {
+            'cache-control': 'public, max-age=3600, must-revalidate',
+            'content-type': "text/javascript; charset=utf-8",
+            'x-content-type-options': 'nosniff'
+        }
+    });
+}
+export { serveAnalyticsAgent };

package/dist/routes/analytics-range.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { AnalyticsDashboardPeriod } from '@byline/admin/analytics';
+export declare function buildAnalyticsDashboardRange(period: AnalyticsDashboardPeriod, now?: Date, earliestReportDay?: string | null): {
+    from: string;
+    to: string;
+};

package/dist/routes/analytics-range.js

@@ -0,0 +1,35 @@
+const UTC_DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+function buildAnalyticsDashboardRange(period, now = new Date(), earliestReportDay = null) {
+    const to = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    if ('ytd' === period) return {
+        from: formatUtcDay(new Date(Date.UTC(to.getUTCFullYear(), 0, 1))),
+        to: formatUtcDay(to)
+    };
+    if ('all' === period) {
+        const toDay = formatUtcDay(to);
+        const earliest = null == earliestReportDay ? toDay : assertUtcDay(earliestReportDay);
+        return {
+            from: earliest <= toDay ? earliest : toDay,
+            to: toDay
+        };
+    }
+    const from = new Date(to);
+    from.setUTCDate(from.getUTCDate() - (period - 1));
+    return {
+        from: formatUtcDay(from),
+        to: formatUtcDay(to)
+    };
+}
+function formatUtcDay(value) {
+    const year = value.getUTCFullYear().toString().padStart(4, '0');
+    const month = (value.getUTCMonth() + 1).toString().padStart(2, '0');
+    const day = value.getUTCDate().toString().padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function assertUtcDay(value) {
+    if (!UTC_DAY_PATTERN.test(value)) throw new Error('analytics report day must use YYYY-MM-DD');
+    const date = new Date(`${value}T00:00:00.000Z`);
+    if (!Number.isFinite(date.valueOf()) || formatUtcDay(date) !== value) throw new Error('analytics report day must be a real UTC calendar day');
+    return value;
+}
+export { buildAnalyticsDashboardRange };

package/dist/routes/create-admin-analytics-route.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export declare function createAdminAnalyticsRoute(path: string): any;

package/dist/routes/create-admin-analytics-route.js

@@ -0,0 +1,108 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createFileRoute, notFound } from "@tanstack/react-router";
+import { AnalyticsDashboard } from "@byline/admin/analytics/components/dashboard";
+import { isAnalyticsDashboardPeriod } from "@byline/analytics/config";
+import { useTranslation } from "@byline/i18n/react";
+import { z } from "zod";
+import { BreadcrumbsClient } from "../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js";
+import { useNavigate } from "../admin-shell/chrome/loose-router.js";
+import { getAnalyticsCountries, getAnalyticsReferrers, getAnalyticsReportCoverage, getAnalyticsRuntime, getAnalyticsSummary, getAnalyticsTop } from "../server-fns/analytics/index.js";
+import { getAdminRoutePath } from "./admin-path.js";
+import { buildAnalyticsDashboardRange } from "./analytics-range.js";
+const periodSchema = z.preprocess((value)=>{
+    if (null == value) return;
+    if ('ytd' === value || 'all' === value) return value;
+    return Number(value);
+}, z.custom((value)=>isAnalyticsDashboardPeriod(value)).optional());
+const searchSchema = z.object({
+    period: periodSchema.catch(void 0)
+});
+function createAdminAnalyticsRoute(path) {
+    const Route = createFileRoute(path)({
+        validateSearch: searchSchema,
+        loaderDeps: ({ search })=>({
+                period: search.period ?? 30
+            }),
+        loader: async ({ deps })=>{
+            const runtime = await getAnalyticsRuntime();
+            if (!runtime.enabled) throw notFound();
+            const coverage = await getAnalyticsReportCoverage();
+            const range = buildAnalyticsDashboardRange(deps.period, new Date(), coverage.summaryFrom);
+            const [summary, pages, downloads, referrers, countries] = await Promise.all([
+                getAnalyticsSummary({
+                    data: range
+                }),
+                getAnalyticsTop({
+                    data: {
+                        ...range,
+                        kind: 'page',
+                        limit: 20
+                    }
+                }),
+                getAnalyticsTop({
+                    data: {
+                        ...range,
+                        kind: 'download',
+                        limit: 20
+                    }
+                }),
+                getAnalyticsReferrers({
+                    data: {
+                        ...range,
+                        limit: 20
+                    }
+                }),
+                getAnalyticsCountries({
+                    data: range
+                })
+            ]);
+            return {
+                data: {
+                    summary,
+                    pages,
+                    downloads,
+                    referrers,
+                    countries,
+                    range,
+                    coverage
+                },
+                period: deps.period
+            };
+        },
+        component: function() {
+            const { data, period } = Route.useLoaderData();
+            const navigate = useNavigate();
+            const { t } = useTranslation('byline-admin');
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(BreadcrumbsClient, {
+                        breadcrumbs: [
+                            {
+                                label: t('chrome.menu.dashboard'),
+                                href: getAdminRoutePath()
+                            },
+                            {
+                                label: t('analytics.title'),
+                                href: getAdminRoutePath('analytics')
+                            }
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(AnalyticsDashboard, {
+                        data: data,
+                        period: period,
+                        onPeriodChange: (nextPeriod)=>{
+                            navigate({
+                                to: getAdminRoutePath('analytics'),
+                                search: {
+                                    period: nextPeriod
+                                }
+                            });
+                        }
+                    })
+                ]
+            });
+        }
+    });
+    return Route;
+}
+export { createAdminAnalyticsRoute };

package/dist/routes/create-admin-layout-route.js

@@ -18,6 +18,7 @@ import { buildLocaleDefinitions } from "../i18n/locale-definitions.js";
 import { bylineAdminServices } from "../integrations/byline-admin-services.js";
 import { BylineAiAdminProvider } from "../integrations/byline-ai.js";
 import { bylineFieldServices } from "../integrations/byline-field-services.js";
+import { getAnalyticsRuntime } from "../server-fns/analytics/index.js";
 import { getCurrentAdminUser } from "../server-fns/auth/index.js";
 import { getScheduledPublicationRuntime } from "../server-fns/collections/index.js";
 import { getActiveLocaleFn, setAdminLocaleFn } from "../server-fns/i18n/index.js";
@@ -28,12 +29,16 @@ function createAdminLayoutRoute(path) {
             const signInPath = getSignInRoutePath();
             try {
                 const user = await getCurrentAdminUser();
-                const activeLocale = await getActiveLocaleFn();
-                const scheduledPublicationRuntime = await getScheduledPublicationRuntime();
+                const [activeLocale, scheduledPublicationRuntime, analyticsRuntime] = await Promise.all([
+                    getActiveLocaleFn(),
+                    getScheduledPublicationRuntime(),
+                    getAnalyticsRuntime()
+                ]);
                 return {
                     user,
                     activeLocale,
-                    scheduledPublicationRuntime
+                    scheduledPublicationRuntime,
+                    analyticsRuntime
                 };
             } catch  {
                 throw redirect({
@@ -45,7 +50,7 @@ function createAdminLayoutRoute(path) {
             }
         },
         component: function() {
-            const { user, activeLocale, scheduledPublicationRuntime } = Route.useRouteContext();
+            const { user, activeLocale, scheduledPublicationRuntime, analyticsRuntime } = Route.useRouteContext();
             const { i18n } = getAdminConfig();
             const localeDefinitions = buildLocaleDefinitions(i18n.admin.locales, i18n.admin.localeDefinitions);
             useEffect(()=>{
@@ -80,6 +85,7 @@ function createAdminLayoutRoute(path) {
                                         className: clsx('byline-admin-layout-main', admin_layout_module.main),
                                         children: [
                                             /*#__PURE__*/ jsx(AdminMenuDrawer, {
+                                                analyticsEnabled: analyticsRuntime.enabled,
                                                 scheduledPublicationEnabled: scheduledPublicationRuntime.enabled
                                             }),
                                             /*#__PURE__*/ jsx(Content, {

package/dist/routes/index.d.ts

@@ -23,6 +23,7 @@ export { getSignInRoutePath } from './sign-in-path.js';
  */
 export { createAdminAccountRoute } from './create-admin-account-route.js';
 export { createAdminActivityRoute } from './create-admin-activity-route.js';
+export { createAdminAnalyticsRoute } from './create-admin-analytics-route.js';
 export { createAdminDashboardRoute } from './create-admin-dashboard-route.js';
 export { createAdminLayoutRoute } from './create-admin-layout-route.js';
 export { createAdminPermissionsRoute } from './create-admin-permissions-route.js';

package/dist/routes/index.js

@@ -2,6 +2,7 @@ export { getAdminRouteId, getAdminRoutePath, isAdminRoutePathActive, isRoutePath
 export { getSignInRoutePath } from "./sign-in-path.js";
 export { createAdminAccountRoute } from "./create-admin-account-route.js";
 export { createAdminActivityRoute } from "./create-admin-activity-route.js";
+export { createAdminAnalyticsRoute } from "./create-admin-analytics-route.js";
 export { createAdminDashboardRoute } from "./create-admin-dashboard-route.js";
 export { createAdminLayoutRoute } from "./create-admin-layout-route.js";
 export { createAdminPermissionsRoute } from "./create-admin-permissions-route.js";

package/dist/server-fns/analytics/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export { type DeleteAnalyticsEventsInput, deleteAnalyticsEvents, rebuildAnalyticsDay, } from './maintenance.js';
+export { type AnalyticsRuntimeState, type AnalyticsTopInput, getAnalyticsCountries, getAnalyticsReferrers, getAnalyticsReportCoverage, getAnalyticsRuntime, getAnalyticsSummary, getAnalyticsTop, } from './queries.js';

package/dist/server-fns/analytics/index.js

@@ -0,0 +1,2 @@
+export { deleteAnalyticsEvents, rebuildAnalyticsDay } from "./maintenance.js";
+export { getAnalyticsCountries, getAnalyticsReferrers, getAnalyticsReportCoverage, getAnalyticsRuntime, getAnalyticsSummary, getAnalyticsTop } from "./queries.js";

package/dist/server-fns/analytics/maintenance.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export interface DeleteAnalyticsEventsInput {
+    from: string;
+    to: string;
+    visitorHash?: string;
+}
+export declare const deleteAnalyticsEvents: import("@tanstack/react-start").RequiredFetcher<undefined, (input: DeleteAnalyticsEventsInput) => DeleteAnalyticsEventsInput, Promise<{
+    deleted: number;
+}>>;
+export declare const rebuildAnalyticsDay: import("@tanstack/react-start").RequiredFetcher<undefined, (input: {
+    day: string;
+}) => {
+    day: string;
+}, Promise<{
+    rebuilt: string;
+}>>;

package/dist/server-fns/analytics/maintenance.js

@@ -0,0 +1,42 @@
+import { createServerFn } from "@tanstack/react-start";
+import { assertAdminActor } from "@byline/admin";
+import { ANALYTICS_ABILITIES } from "@byline/admin/analytics";
+import { getAdminRequestContext } from "@byline/client/server";
+const deleteAnalyticsEvents = createServerFn({
+    method: 'POST'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsMaintenance();
+    const { getAnalytics } = await import("@byline/analytics");
+    const from = parseInstant(data.from, 'from');
+    const to = parseInstant(data.to, 'to');
+    const deleted = await getAnalytics().deleteEvents({
+        from,
+        to,
+        ...null == data.visitorHash ? {} : {
+            visitorHash: data.visitorHash
+        }
+    });
+    return {
+        deleted
+    };
+});
+const rebuildAnalyticsDay = createServerFn({
+    method: 'POST'
+}).validator((input)=>input).handler(async ({ data })=>{
+    await assertAnalyticsMaintenance();
+    const { getAnalytics } = await import("@byline/analytics");
+    await getAnalytics().rebuildDay(data.day);
+    return {
+        rebuilt: data.day
+    };
+});
+async function assertAnalyticsMaintenance() {
+    const context = await getAdminRequestContext();
+    assertAdminActor(context, ANALYTICS_ABILITIES.maintain);
+}
+function parseInstant(value, label) {
+    const date = new Date(value);
+    if (Number.isNaN(date.valueOf())) throw new Error(`analytics ${label} must be an ISO instant`);
+    return date;
+}
+export { deleteAnalyticsEvents, rebuildAnalyticsDay };