@byline/cli 3.21.0 → 4.1.0

package/dist/templates/byline-examples/scripts/regenerate-media.ts

@@ -23,21 +23,28 @@
  * The script orchestrates the same two-step flow the admin UI uses
  * for an existing document — upload (createDocument: false) followed by
  * a document update — but as a single "one-shot" Client SDK pass per
- * media item. Variants and the original written under fresh paths;
- * the previous original + variant files are deleted once the document
- * has been re-pointed at the new value.
+ * media item. Variants and the original are written under fresh paths.
+ * Previous files are retained because immutable historical versions — or an
+ * older published version while the current version is draft — may still
+ * reference them. Storage reclamation requires a separate reference-aware
+ * garbage collector.
  *
  * Bypass-MIME images (SVG / GIF) are passed through untouched — Sharp
  * does not produce variants for them, so the only effect is a new
  * storagePath on a re-stored copy.
  *
- * Status preservation: `updateDocument` always stamps new versions with
- * the workflow's default status (`getDefaultStatus`, i.e. the first
- * declared status — `'draft'` for media). After the update we step the
- * new version forward through `changeStatus` until it lands in the same
- * slot the original occupied. Skipping this leaves the previously-
- * published version (with the old variant set) as what
- * `current_published_documents` returns to public readers.
+ * Status preservation: `updateDocument` stamps new versions with the
+ * workflow's default status (`'draft'` for media). The script wraps that
+ * update and a direct restoration of the captured status in one database
+ * transaction. This is a deliberate maintenance-only use of adapter
+ * commands: an archived item is never temporarily published, and callers
+ * cannot observe the intermediate draft. Run without concurrent editorial
+ * writes to the media collection.
+ *
+ * Safety: the generated variant names must exactly match the current schema
+ * before the document is changed. A failed upload/update is compensated by
+ * deleting the newly-written files, failures are collected per document, and
+ * the process exits non-zero after attempting the remaining items.
  *
  * Currently requires the local storage provider — pulls bytes back via
  * the provider's `uploadDir`. Variant generation itself is provider-
@@ -53,17 +60,22 @@ import fs from 'node:fs'
 import path from 'node:path'
 
 import { createSuperAdminContext } from '@byline/auth'
-import { type CollectionHandle, createBylineClient } from '@byline/client'
+import { createBylineClient } from '@byline/client'
 import {
   type FieldUploadContext,
   getCollectionDefinition,
   getServerConfig,
-  getWorkflowStatuses,
-  type StoredFileValue,
 } from '@byline/core'
 import { extractImageMeta, generateImageVariants, isBypassMimeType } from '@byline/core/image'
 import { uploadField as coreUploadField } from '@byline/core/services'
 
+import type { MediaFields } from '@byline/generated-types'
+import {
+  assertCompleteVariantSet,
+  replaceMediaVersionPreservingStatus,
+  storedFilePaths,
+} from './regenerate-media-operation.js'
+
 const COLLECTION_PATH = 'media'
 const FIELD_NAME = 'image'
 
@@ -102,13 +114,13 @@ async function run(): Promise<void> {
   // Snapshot the full set up-front. Each update bumps `updated_at` and
   // reorders the default sort, so paging through a moving window would
   // either skip or re-visit rows. Capture `status` so we can restore
-  // each doc to its original workflow slot after the regenerated draft
-  // is written (see `restoreStatus` below).
+  // each doc to its original workflow slot inside the replacement
+  // transaction.
   const allDocs: {
     id: string
     path: string
     status: string
-    fields: Record<string, any>
+    fields: MediaFields
   }[] = []
   const pageSize = 100
   for (let page = 1; ; page++) {
@@ -123,7 +135,7 @@ async function run(): Promise<void> {
         id: d.id,
         path: d.path,
         status: d.status,
-        fields: d.fields as Record<string, any>,
+        fields: d.fields,
       })
     }
     if (result.docs.length < pageSize) break
@@ -150,113 +162,138 @@ async function run(): Promise<void> {
     },
   }
 
+  const imageField = definition.fields.find((field) => field.name === FIELD_NAME)
+  if (imageField == null || (imageField.type !== 'image' && imageField.type !== 'file')) {
+    throw new Error(
+      `regenerate-media: '${COLLECTION_PATH}.${FIELD_NAME}' is not an image/file field.`
+    )
+  }
+  if (imageField.upload == null) {
+    throw new Error(
+      `regenerate-media: '${COLLECTION_PATH}.${FIELD_NAME}' has no upload configuration.`
+    )
+  }
+
   let processed = 0
   let skipped = 0
+  const failures: Error[] = []
 
   for (const doc of allDocs) {
-    const image = doc.fields[FIELD_NAME] as StoredFileValue | undefined | null
+    const image = doc.fields[FIELD_NAME]
     if (image == null || !image.storagePath) {
       console.log(`  - skip ${doc.id} (${doc.path}) — no image value`)
       skipped += 1
       continue
     }
 
+    const oldPaths = storedFilePaths(image)
     const sourceAbsolutePath = path.join(uploadDir, image.storagePath)
     let buffer: Buffer
     try {
       buffer = await fs.promises.readFile(sourceAbsolutePath)
     } catch (err) {
       console.error(
-        `  ! skip ${doc.id} (${doc.path}) — failed to read original at ${sourceAbsolutePath}:`,
+        `  ! fail ${doc.id} (${doc.path}) — failed to read original at ${sourceAbsolutePath}:`,
         err
       )
-      skipped += 1
+      failures.push(asDocumentError(doc.id, doc.path, err))
       continue
     }
 
-    const uploadResult = await coreUploadField(
-      { ...baseUploadCtx, requestContext },
-      {
-        buffer,
-        originalFilename: image.originalFilename || image.filename,
-        mimeType: image.mimeType,
-        fileSize: buffer.byteLength,
-        shouldCreateDocument: false,
-      }
-    )
-
-    const nextFields = { ...doc.fields, [FIELD_NAME]: uploadResult.storedFile }
-    await handle.update(doc.id, nextFields)
+    let freshPaths = new Set<string>()
+    try {
+      const uploadResult = await coreUploadField(
+        { ...baseUploadCtx, requestContext },
+        {
+          buffer,
+          originalFilename: image.originalFilename || image.filename,
+          mimeType: image.mimeType,
+          fileSize: buffer.byteLength,
+          shouldCreateDocument: false,
+        }
+      )
+      freshPaths = storedFilePaths(uploadResult.storedFile)
 
-    // `updateDocument` always stamps the new version with the workflow's
-    // default status (the first key — 'draft' for media), so without this
-    // step the public read path keeps returning the prior published
-    // version with the old variant set. Walk the new version forward to
-    // the slot the doc originally occupied.
-    await restoreStatus(handle, definition, doc.id, doc.status)
+      const expectedVariantNames = isBypassMimeType(image.mimeType)
+        ? []
+        : (imageField.upload.sizes ?? []).map((size) => size.name)
+      assertCompleteVariantSet(uploadResult.storedFile, expectedVariantNames)
 
-    // Best-effort orphan cleanup. Failures are non-fatal — the new
-    // value is already persisted, the doc is consistent, the unused
-    // bytes are just dead weight on disk.
-    const orphans: string[] = [
-      image.storagePath,
-      ...(image.variants ?? []).map((v) => v.storagePath).filter((p): p is string => Boolean(p)),
-    ]
-    for (const orphan of orphans) {
-      try {
-        await storage.delete(orphan)
-      } catch (err) {
-        console.warn(`    ! failed to delete orphan ${orphan}:`, err)
+      const collisions = [...freshPaths].filter((storagePath) => oldPaths.has(storagePath))
+      if (collisions.length > 0) {
+        throw new Error(
+          `regenerate-media: upload hooks reused existing storage path(s): ${collisions.join(', ')}. ` +
+            'Fresh paths are required for an atomic replacement.'
+        )
       }
-    }
 
-    const variantSummary =
-      uploadResult.storedFile.variants?.map((v) => `${v.name}:${v.format ?? '?'}`).join(', ') ??
-      '(none)'
-    console.log(
-      `  - ${doc.id} (${doc.path}) → ${uploadResult.storedFile.storagePath} [${variantSummary}]`
-    )
-    processed += 1
+      const nextFields = { ...doc.fields, [FIELD_NAME]: uploadResult.storedFile }
+      await replaceMediaVersionPreservingStatus({
+        db: config.db,
+        definition,
+        collectionId,
+        handle,
+        documentId: doc.id,
+        fields: nextFields,
+        targetStatus: doc.status,
+      })
+
+      const variantSummary =
+        uploadResult.storedFile.variants?.map((v) => `${v.name}:${v.format ?? '?'}`).join(', ') ??
+        '(none)'
+      console.log(
+        `  - ${doc.id} (${doc.path}) → ${uploadResult.storedFile.storagePath} [${variantSummary}]`
+      )
+      processed += 1
+    } catch (err) {
+      // The document transaction did not commit. Remove every fresh path we
+      // know about, but never delete a path that belonged to the old value — a
+      // deterministic beforeStore hook may already have overwritten it.
+      const rollbackPaths = new Set([...freshPaths].filter((storagePath) => !oldPaths.has(storagePath)))
+      const cleanupErrors = await deletePathsBestEffort(storage, rollbackPaths)
+      const failure = asDocumentError(doc.id, doc.path, err)
+      failures.push(
+        cleanupErrors.length === 0
+          ? failure
+          : new AggregateError(
+              [failure, ...cleanupErrors],
+              `regenerate-media: operation and rollback cleanup failed for '${doc.path}'`
+            )
+      )
+      console.error(`  ! fail ${doc.id} (${doc.path}):`, err)
+    }
   }
 
   console.log(
-    `regenerate-media: done. processed=${processed}, skipped=${skipped}, total=${allDocs.length}.`
+    `regenerate-media: done. processed=${processed}, skipped=${skipped}, ` +
+      `failed=${failures.length}, total=${allDocs.length}.`
   )
+  if (failures.length > 0) {
+    throw new AggregateError(failures, `regenerate-media: ${failures.length} document(s) failed`)
+  }
 }
 
-/**
- * Walk the workflow ladder forward from the new version's status (the
- * workflow's first slot, set by `updateDocument`) to `targetStatus`.
- *
- * `validateStatusTransition` allows ±1-step moves and reset-to-first, so
- * jumping straight from 'draft' to 'archived' is rejected — we step
- * through 'published' on the way. A target equal to the current status
- * is a no-op (transition validation accepts identical-status moves but
- * we skip the work).
- *
- * Throws if `targetStatus` is not declared on the collection's workflow,
- * since that signals a stale snapshot or a workflow definition that has
- * been edited since the docs were created.
- */
-async function restoreStatus(
-  handle: CollectionHandle,
-  definition: Parameters<typeof getWorkflowStatuses>[0],
-  documentId: string,
-  targetStatus: string
-): Promise<void> {
-  const statuses = getWorkflowStatuses(definition).map((s) => s.name)
-  const targetIndex = statuses.indexOf(targetStatus)
-  if (targetIndex === -1) {
-    throw new Error(
-      `restoreStatus: status '${targetStatus}' is not declared on collection ` +
-        `'${definition.path}' (declared: ${statuses.join(', ')}).`
-    )
-  }
-  // The new version is always at index 0 (workflow default). Anything at
-  // index > 0 needs that many forward transitions.
-  for (let i = 1; i <= targetIndex; i++) {
-    await handle.changeStatus(documentId, statuses[i] as string)
+async function deletePathsBestEffort(
+  storage: NonNullable<ReturnType<typeof getServerConfig>['storage']>,
+  storagePaths: Iterable<string>
+): Promise<Error[]> {
+  const errors: Error[] = []
+  for (const storagePath of storagePaths) {
+    try {
+      await storage.delete(storagePath)
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err))
+      errors.push(error)
+      console.warn(`    ! failed to delete ${storagePath}:`, error)
+    }
   }
+  return errors
+}
+
+function asDocumentError(documentId: string, documentPath: string, err: unknown): Error {
+  return new Error(`regenerate-media: '${documentPath}' (${documentId}) failed`, {
+    cause: err,
+  })
 }
 
 run()

package/dist/templates/byline-examples/server.config.ts

@@ -28,8 +28,10 @@ import {
 import { migrate, postgresSearch } from '@byline/search-postgres'
 import { localStorageProvider } from '@byline/storage-local'
 
-import { getAdminBylineClient } from './client.server.js'
+import { getAdminBylineClient } from '@byline/client/server'
+import { registerTanstackStartHostBridge } from '@byline/host-tanstack-start/integrations/host-bridge'
 import { collections } from './collections/index.js'
+import { serverHooks } from './collections/server-hooks.js'
 import { i18n } from './i18n.js'
 import { DEFAULT_SERVER_URL, routes } from './routes.js'
 
@@ -134,11 +136,18 @@ async function buildBylineCore(): Promise<BylineCore<AdminStore>> {
     signingSecret,
   })
 
+  // Register the TanStack Start `HostRequestBridge` before any
+  // request-bound client getter (`@byline/client/server`) can run —
+  // structural at server boot rather than dependent on which host
+  // module happens to load first.
+  registerTanstackStartHostBridge()
+
   const core = await initBylineCore<AdminStore>({
     serverURL,
     i18n,
     routes,
     collections,
+    hooks: serverHooks,
     db,
     adminStore,
     // Site-wide default storage provider — used by any upload collection
@@ -163,8 +172,7 @@ async function buildBylineCore(): Promise<BylineCore<AdminStore>> {
     }),
     // S3-compatible alternative (AWS S3 / Cloudflare R2 / MinIO). Replace
     // the `localStorageProvider` block above with the call below and add
-    // the corresponding `BYLINE_STORAGE_S3_*` entries to your `.env.local`
-    // (see `apps/webapp/.env.local.example`).
+    // the corresponding `BYLINE_STORAGE_S3_*` entries to your `.env.local`.
     //
     // On AWS with an IAM role / instance profile, omit `accessKeyId` and
     // `secretAccessKey` so the SDK resolves credentials via its default
@@ -204,11 +212,11 @@ async function buildBylineCore(): Promise<BylineCore<AdminStore>> {
       //
       // We pass `getAdminBylineClient` (not the public client) because
       // admin server fns are the only call sites that read documents in
-      // the admin webapp today — the populate phase inherits whichever
+      // the admin host today — the populate phase inherits whichever
       // actor the request resolved. A future public-facing host would
       // register its own client whose `requestContext` factory resolves
-      // an end-user actor instead. See `@byline/host-tanstack-start/
-      // integrations/byline-client.ts` for how the admin client is built.
+      // an end-user actor instead. See `packages/client/src/server/
+      // clients.ts` (`@byline/client/server`) for how the admin client is built.
       //
       // Why a getter, not a value: `getAdminBylineClient()` reads the
       // server config singleton, which is only populated *after*

package/dist/templates/host/vite.config.ts

@@ -1,4 +1,5 @@
 import { devtools } from '@tanstack/devtools-vite'
+import { bylineClientHookBoundary } from '@byline/host-tanstack-start/vite'
 import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 
 import tailwindcss from '@tailwindcss/vite'
@@ -158,6 +159,7 @@ const config = defineConfig({
   },
   plugins: [
     browserAsyncHooksAlias(),
+    bylineClientHookBoundary(),
     devtools(),
     nitro({
       preset: 'node',

package/dist/templates/routes/_byline/route.lazy.tsx

@@ -24,8 +24,7 @@
  * Both call `defineClientConfig` idempotently.
  *
  * If you also want to use the Byline UI components on your public site,
- * import the same stylesheets from your front-end's pathless layout
- * instead (e.g. `_front-end/route.tsx`).
+ * import the same stylesheets from your public layout route as well.
  */
 
 import { createLazyFileRoute, Outlet } from '@tanstack/react-router'

package/dist/templates/routes/_byline/route.tsx

@@ -9,7 +9,7 @@
 /**
  * Pathless route definition for everything Byline-rendered (the admin
  * shell and the sign-in page). The `_byline` prefix doesn't contribute
- * to URL paths — `/_byline/admin/...` resolves to `/admin/...` and
+ * to URL paths — by default, `/_byline/admin/...` resolves to `/admin/...` and
  * `/_byline/sign-in` resolves to `/sign-in`.
  *
  * This file is intentionally light. The router needs the route definition

package/dist/templates/ui-byline/blocks/photo-block/index.tsx

@@ -5,15 +5,14 @@ import type React from 'react'
 import { Container, FadeInLift } from '@byline/ui/react'
 import cx from 'classnames'
 
-import type { MediaFields, PhotoBlockData } from '~/generated/collection-types.js'
-
 import { ResponsiveImage } from '@/ui/byline/components/responsive-image'
 import { LexicalRichText } from '@/ui/byline/components/richtext-lexical'
+import type { PopulatedPhotoBlockData } from '@/ui/byline/types/content'
 import type { Locale } from '@/ui/byline/types/i18n'
 
 interface Props {
   id: string
-  block: PhotoBlockData
+  block: PopulatedPhotoBlockData
   lng: Locale
   constrainedLayout?: boolean
   className?: string
@@ -28,27 +27,26 @@ export function PhotoBlock({
 }: Props): React.JSX.Element | null {
   const { photo, alt, caption, display } = block
 
-  // The `photo` relation must be populated (`populate: { photo: '*' }`) for
-  // the front-end to render an image. When populated, the value is a
-  // `PopulatedRelationValue` envelope — `{ ...rel, _resolved: true,
-  // document: <MediaFields> }`. Bail out if the relation is missing or
-  // unpopulated.
-  if (photo == null || (photo as { _resolved?: boolean })._resolved !== true) {
-    return null
-  }
-  const media = (photo as unknown as { document: MediaFields }).document
+  // Missing, unresolved, and cycle-suppressed relations have no document.
+  const media = photo?.document?.fields
+  if (media == null) return null
 
   const Comp = display === 'full_width' ? 'div' : Container
 
-  // TODO: caption is a Lexical richText field — type properly once the
-  // Lexical node shape is modelled in @byline/core.
-  const captionDoc = caption as Record<string, any> | undefined
+  const captionRoot =
+    caption != null && !Array.isArray(caption) && typeof caption === 'object'
+      ? caption.root
+      : undefined
+  const captionChildren =
+    captionRoot != null && !Array.isArray(captionRoot) && typeof captionRoot === 'object'
+      ? captionRoot.children
+      : undefined
 
   return (
     <Comp
       id={id}
       className={cx(
-        'px-0 pt-4',
+        'px-0',
         {
           'lg:max-w-[920px] xl:max-w-[920px] 2xl:max-w-[920px] mx-auto': display === 'default',
         },
@@ -64,12 +62,10 @@ export function PhotoBlock({
           className="photo-block"
           imgClassName="photo-block--photo"
         />
-        {captionDoc != null && (
-          <Container
-            className={cx('bg-white dark:bg-canvas-900 py-2', { 'px-0': constrainedLayout })}
-          >
-            <div className="photo-block--caption">
-              <LexicalRichText lng={lng} nodes={captionDoc?.root?.children} />
+        {captionChildren != null && (
+          <Container className={cx('py-2', { 'px-0': constrainedLayout })}>
+            <div className="photo-block--caption [&_p]:m-0 muted text-[1rem]">
+              <LexicalRichText lng={lng} nodes={captionChildren} />
             </div>
           </Container>
         )}

package/dist/templates/ui-byline/blocks/richtext-block/index.tsx

@@ -3,7 +3,7 @@
 import { Container } from '@byline/ui/react'
 import cx from 'classnames'
 
-import type { RichTextBlockData } from '~/generated/collection-types.js'
+import type { RichTextBlockData } from '@byline/generated-types'
 
 import { LexicalRichText } from '@/ui/byline/components/richtext-lexical'
 import type { Locale } from '@/ui/byline/types/i18n'

package/dist/templates/ui-byline/components/admonition/index.tsx

@@ -1,4 +1,4 @@
-'use clients'
+'use client'
 
 import type React from 'react'
 
@@ -28,13 +28,16 @@ export function AdmonitionSerializer({
   options: SerializeOptions
 }): React.JSX.Element {
   const intent = intentMap[node.admonitionType as keyof typeof intentMap]
+  // Admonitions are ElementNodes, so their body is stored directly in children.
   return (
-    <Alert title={node.title} intent={intent} close={false} className="rounded-none">
-      {node?.content?.editorState?.root?.children != null ? (
-        serialize({ nodes: node?.content?.editorState?.root?.children, lng, options })
-      ) : (
-        <span>Content not found for admonition.</span>
-      )}
-    </Alert>
+    <div className="not-prose pt-6 pb-8">
+      <Alert title={node.title} intent={intent} close={false} className="not-prose my-0">
+        {node.children != null ? (
+          serialize({ nodes: node.children, lng, options })
+        ) : (
+          <span>Content not found for admonition.</span>
+        )}
+      </Alert>
+    </div>
   )
 }

package/dist/templates/ui-byline/components/code/code.tsx

@@ -10,14 +10,16 @@ interface CodeProps extends CodeIntrinsicProps {
   className?: string
   title?: string
   code: string
-  language?: string
+  language?: string | null
 }
 
-export function Code({ code, className, language = 'jsx' }: CodeProps): React.JSX.Element {
+export function Code({ code, className, language }: CodeProps): React.JSX.Element {
+  // Prism calls `.toLowerCase()` on this value, so null and empty legacy values need a fallback.
+  const resolvedLanguage = language != null && language.length > 0 ? language : 'typescript'
   return (
-    <Highlight theme={themes.oneDark} code={code} language={language}>
+    <Highlight theme={themes.oneDark} code={code} language={resolvedLanguage}>
       {({ tokens, getLineProps, getTokenProps }) => (
-        <div className="code scroller group overflow-y-auto rounded border border-theme-600 relative">
+        <div className="code scroller group overflow-y-auto rounded border border-theme-600 relative mb-4">
           <CopyButton
             variant="outlined"
             intent="primary"

package/dist/templates/ui-byline/components/link/lang-link.tsx

@@ -1,17 +1,13 @@
 /**
  * Locale-aware Link STUB.
  *
- * The reference webapp ships a real `LangLink` that injects an optional
- * `{-$lng}` path parameter onto TanStack Router's `<Link>` so that the
- * current locale survives client-side navigation. This stub is a thin
- * pass-through — it accepts the `lng` prop but does NOT prefix URLs.
+ * This stub is a thin pass-through: it accepts the `lng` prop but does not
+ * prefix URLs. A localized app can replace the body with a wrapper that
+ * injects its locale path parameter into TanStack Router's `<Link>`.
  *
  * If your app is single-locale, this is fine as-is.
  *
- * If you have a multi-locale strategy, replace the body with your own
- * Link wrapper. The reference implementation lives at
- *   apps/webapp/src/i18n/components/lang-link.tsx
- * in https://github.com/Byline-CMS/bylinecms.dev.
+ * If you have a multi-locale strategy, replace the body with your own Link wrapper.
  */
 
 import type React from 'react'

package/dist/templates/ui-byline/components/link/link-field.tsx

@@ -84,14 +84,15 @@ function getHref(args: LinkFieldAttributes): string {
   }
 
   const hrefIsLocal = ['tel:', 'mailto:', '/'].some((prefix) => href.startsWith(prefix))
-  if (!hrefIsLocal) {
+  // Relative custom hrefs are valid but cannot be passed to URL without a base.
+  if (!hrefIsLocal && /^[a-z][a-z\d+.-]*:/i.test(href)) {
     try {
       const objectURL = new URL(href)
       if (objectURL.origin === publicWebsiteUrl) {
         href = objectURL.href.replace(publicWebsiteUrl, '')
       }
     } catch (e) {
-      console.error(`Failed to format url: ${href}`, e) // eslint-disable-line no-console
+      console.error(`Failed to format url: ${href}`, e)
     }
   }
 

package/dist/templates/ui-byline/components/link/link-lexical.tsx

@@ -7,8 +7,6 @@ import cx from 'classnames'
 import { LangLink } from '@/ui/byline/components/link/lang-link'
 import type { Locale } from '@/ui/byline/types/i18n'
 
-// import { getPublicWebsiteUrl } from '@/utils/utils.framework.ts'
-
 interface BaseLinkAttributes {
   newTab?: boolean
   nofollow?: boolean
@@ -134,13 +132,16 @@ function getHref(args: LinkAttributes): string {
   }
 
   if (!isLocalHref(href)) {
-    try {
-      const objectURL = new URL(href)
-      if (objectURL.origin === publicWebsiteUrl) {
-        href = objectURL.href.replace(publicWebsiteUrl, '')
+    // Relative custom hrefs are valid but cannot be passed to URL without a base.
+    if (/^[a-z][a-z\d+.-]*:/i.test(href)) {
+      try {
+        const objectURL = new URL(href)
+        if (objectURL.origin === publicWebsiteUrl) {
+          href = objectURL.href.replace(publicWebsiteUrl, '')
+        }
+      } catch (e) {
+        console.error(`Failed to format url: ${href}`, e)
       }
-    } catch (e) {
-      console.error(`Failed to format url: ${href}`, e) // eslint-disable-line no-console
     }
   }