@byline/host-tanstack-start 4.14.1 → 4.16.0

package/dist/admin-shell/scheduled-publications/list_module.css

@@ -0,0 +1,97 @@
+.head-oj4QbV {
+  margin-bottom: var(--spacing-16);
+}
+
+.title-lm1z74 {
+  margin-bottom: var(--spacing-4);
+}
+
+.intro-clPFM7 {
+  color: var(--gray-500);
+  margin: 0;
+}
+
+.health-KAg5x5 {
+  margin-bottom: var(--spacing-16);
+}
+
+.controls-dRon5S {
+  justify-content: space-between;
+  align-items: flex-end;
+  gap: var(--spacing-16);
+  margin-bottom: var(--spacing-4);
+  flex-wrap: wrap;
+  display: flex;
+}
+
+.filters-help-DWQ3Wy {
+  margin: 0 0 var(--spacing-16);
+  color: var(--gray-500);
+  font-size: var(--font-size-sm);
+}
+
+.filters-x7PuG5 {
+  align-items: flex-end;
+  gap: var(--spacing-12);
+  flex-wrap: wrap;
+  display: flex;
+}
+
+.filter-TXeSAI {
+  gap: var(--spacing-4);
+  flex-direction: column;
+  min-width: 12rem;
+  display: flex;
+}
+
+.filter-authorizer-rDbHwh .byline-input-wrapper {
+  min-width: 22rem;
+}
+
+.filter-actions-dbQWCO {
+  align-items: center;
+  gap: var(--spacing-8);
+  padding-bottom: .1rem;
+  display: flex;
+}
+
+.tableWrap-wqdsOy {
+  margin-top: .75rem;
+  overflow-x: auto;
+}
+
+.collection-sBqska, .zone-ikRViN, .error-frhrx4 {
+  margin-top: var(--spacing-4);
+  color: var(--gray-500);
+  font-size: var(--font-size-xs);
+  display: block;
+}
+
+.instant-PTgCBK {
+  white-space: nowrap;
+}
+
+.authorizer-orWXlf {
+  font-family: var(--font-family-mono, monospace);
+  font-size: var(--font-size-xs);
+  overflow-wrap: anywhere;
+}
+
+.error-frhrx4 {
+  max-width: 24rem;
+  color: var(--red-600);
+  white-space: normal;
+}
+
+.empty-K7NcOV {
+  padding: var(--spacing-32) 0;
+  color: var(--gray-500);
+  text-align: center;
+}
+
+.pagerBottom-Sf0_9J {
+  margin-top: var(--spacing-16);
+  justify-content: flex-end;
+  display: flex;
+}
+

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,7 +18,9 @@ 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";
 import { getSignInRoutePath } from "./sign-in-path.js";
 function createAdminLayoutRoute(path) {
@@ -27,10 +29,16 @@ function createAdminLayoutRoute(path) {
             const signInPath = getSignInRoutePath();
             try {
                 const user = await getCurrentAdminUser();
-                const activeLocale = await getActiveLocaleFn();
+                const [activeLocale, scheduledPublicationRuntime, analyticsRuntime] = await Promise.all([
+                    getActiveLocaleFn(),
+                    getScheduledPublicationRuntime(),
+                    getAnalyticsRuntime()
+                ]);
                 return {
                     user,
-                    activeLocale
+                    activeLocale,
+                    scheduledPublicationRuntime,
+                    analyticsRuntime
                 };
             } catch  {
                 throw redirect({
@@ -42,7 +50,7 @@ function createAdminLayoutRoute(path) {
             }
         },
         component: function() {
-            const { user, activeLocale } = Route.useRouteContext();
+            const { user, activeLocale, scheduledPublicationRuntime, analyticsRuntime } = Route.useRouteContext();
             const { i18n } = getAdminConfig();
             const localeDefinitions = buildLocaleDefinitions(i18n.admin.locales, i18n.admin.localeDefinitions);
             useEffect(()=>{
@@ -76,7 +84,10 @@ function createAdminLayoutRoute(path) {
                                     /*#__PURE__*/ jsxs("main", {
                                         className: clsx('byline-admin-layout-main', admin_layout_module.main),
                                         children: [
-                                            /*#__PURE__*/ jsx(AdminMenuDrawer, {}),
+                                            /*#__PURE__*/ jsx(AdminMenuDrawer, {
+                                                analyticsEnabled: analyticsRuntime.enabled,
+                                                scheduledPublicationEnabled: scheduledPublicationRuntime.enabled
+                                            }),
                                             /*#__PURE__*/ jsx(Content, {
                                                 children: /*#__PURE__*/ jsx(Outlet, {})
                                             })

package/dist/routes/create-admin-scheduled-publications-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 createAdminScheduledPublicationsRoute(path: string): any;

package/dist/routes/create-admin-scheduled-publications-route.js

@@ -0,0 +1,66 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createFileRoute, notFound } from "@tanstack/react-router";
+import { useTranslation } from "@byline/i18n/react";
+import { z } from "zod";
+import { BreadcrumbsClient } from "../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js";
+import { ScheduledPublicationsView } from "../admin-shell/scheduled-publications/list.js";
+import { getScheduledPublicationRuntime, listScheduledPublications } from "../server-fns/collections/index.js";
+import { getAdminRoutePath } from "./admin-path.js";
+const searchSchema = z.object({
+    page: z.coerce.number().int().min(1).optional().catch(void 0),
+    page_size: z.coerce.number().int().min(1).max(100).optional().catch(void 0),
+    state: z["enum"]([
+        'armed',
+        'needs_reconfirm'
+    ]).optional().catch(void 0),
+    lastAuthorizedBy: z.string().trim().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).optional().catch(void 0)
+});
+function createAdminScheduledPublicationsRoute(path) {
+    const Route = createFileRoute(path)({
+        shouldReload: true,
+        validateSearch: searchSchema,
+        loaderDeps: ({ search })=>search,
+        loader: async ({ deps })=>{
+            const runtime = await getScheduledPublicationRuntime();
+            if (!runtime.enabled) throw notFound();
+            const data = await listScheduledPublications({
+                data: {
+                    page: deps.page,
+                    pageSize: deps.page_size,
+                    states: null == deps.state ? void 0 : [
+                        deps.state
+                    ],
+                    lastAuthorizedBy: deps.lastAuthorizedBy
+                }
+            });
+            return {
+                data
+            };
+        },
+        component: function() {
+            const { data } = Route.useLoaderData();
+            const { t } = useTranslation('byline-admin');
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(BreadcrumbsClient, {
+                        breadcrumbs: [
+                            {
+                                label: t('chrome.menu.dashboard'),
+                                href: getAdminRoutePath()
+                            },
+                            {
+                                label: t('scheduledPublication.list.title'),
+                                href: getAdminRoutePath('scheduled-publications')
+                            }
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(ScheduledPublicationsView, {
+                        data: data
+                    })
+                ]
+            });
+        }
+    });
+    return Route;
+}
+export { createAdminScheduledPublicationsRoute };