130 lines
4.1 KiB
TypeScript
130 lines
4.1 KiB
TypeScript
import { RTETypeEnum } from "@/types/rte/enums"
|
|
import type { RawMetadataSchema } from "@/types/trpc/routers/contentstack/metadata"
|
|
|
|
export const affix = "metadata"
|
|
|
|
/**
|
|
* Truncates the given text "intelligently" based on the last period found near the max length.
|
|
*
|
|
* - If a period exists within the extended range (`maxLength` to `maxLength + maxExtension`),
|
|
* the function truncates after the closest period to `maxLength`.
|
|
* - If no period is found in the range, it truncates the text after the last period found in the max length of the text.
|
|
* - If no periods exist at all, it truncates at `maxLength` and appends ellipsis (`...`).
|
|
*
|
|
* @param {string} text - The input text to be truncated.
|
|
* @param {number} [maxLength=150] - The desired maximum length of the truncated text.
|
|
* @param {number} [minLength=120] - The minimum allowable length for the truncated text.
|
|
* @param {number} [maxExtension=10] - The maximum number of characters to extend beyond `maxLength` to find a period.
|
|
* @returns {string} - The truncated text.
|
|
*/
|
|
function truncateTextAfterLastPeriod(
|
|
text: string,
|
|
maxLength: number = 150,
|
|
minLength: number = 120,
|
|
maxExtension: number = 10
|
|
): string {
|
|
if (text.length <= maxLength) {
|
|
return text
|
|
}
|
|
|
|
// Define the extended range
|
|
const extendedEnd = Math.min(text.length, maxLength + maxExtension)
|
|
const extendedText = text.slice(0, extendedEnd)
|
|
|
|
// Find all periods within the extended range and filter after minLength to get valid periods
|
|
const periodsInRange = [...extendedText.matchAll(/\./g)].map(
|
|
({ index }) => index
|
|
)
|
|
const validPeriods = periodsInRange.filter((index) => index + 1 >= minLength)
|
|
|
|
if (validPeriods.length > 0) {
|
|
// Find the period closest to maxLength
|
|
const closestPeriod = validPeriods.reduce((closest, index) =>
|
|
Math.abs(index + 1 - maxLength) < Math.abs(closest + 1 - maxLength)
|
|
? index
|
|
: closest
|
|
)
|
|
return extendedText.slice(0, closestPeriod + 1)
|
|
}
|
|
|
|
// Fallback: If no period is found within the valid range, look for the last period in the truncated text
|
|
const maxLengthText = text.slice(0, maxLength)
|
|
const lastPeriodIndex = maxLengthText.lastIndexOf(".")
|
|
if (lastPeriodIndex !== -1) {
|
|
return text.slice(0, lastPeriodIndex + 1)
|
|
}
|
|
|
|
// Final fallback: Return maxLength text including ellipsis
|
|
return `${maxLengthText}...`
|
|
}
|
|
|
|
export function getTitle(data: RawMetadataSchema) {
|
|
const metadata = data.web?.seo_metadata
|
|
if (metadata?.title) {
|
|
return metadata.title
|
|
}
|
|
if (data.web?.breadcrumbs?.title) {
|
|
return data.web.breadcrumbs.title
|
|
}
|
|
if (data.heading) {
|
|
return data.heading
|
|
}
|
|
if (data.header?.heading) {
|
|
return data.header.heading
|
|
}
|
|
return ""
|
|
}
|
|
|
|
export function getDescription(data: RawMetadataSchema) {
|
|
const metadata = data.web?.seo_metadata
|
|
if (metadata?.description) {
|
|
return metadata.description
|
|
}
|
|
if (data.preamble) {
|
|
return truncateTextAfterLastPeriod(data.preamble)
|
|
}
|
|
if (data.header?.preamble) {
|
|
return truncateTextAfterLastPeriod(data.header.preamble)
|
|
}
|
|
if (data.blocks?.length) {
|
|
const jsonData = data.blocks[0].content?.content?.json
|
|
// Finding the first paragraph with text
|
|
const firstParagraph = jsonData?.children?.find(
|
|
(child) => child.type === RTETypeEnum.p && child.children[0].text
|
|
)
|
|
|
|
if (firstParagraph?.children?.length) {
|
|
return firstParagraph.children[0].text
|
|
? truncateTextAfterLastPeriod(firstParagraph.children[0].text)
|
|
: ""
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
export function getImages(data: RawMetadataSchema) {
|
|
const metadataImage = data.web?.seo_metadata?.seo_image
|
|
const heroImage = data.hero_image
|
|
|
|
// Currently we don't have the possibility to get smaller images from ImageVault (2024-11-15)
|
|
if (metadataImage) {
|
|
return [
|
|
{
|
|
url: metadataImage.url,
|
|
width: metadataImage.dimensions.width,
|
|
height: metadataImage.dimensions.height,
|
|
},
|
|
]
|
|
}
|
|
if (heroImage) {
|
|
return [
|
|
{
|
|
url: heroImage.url,
|
|
width: heroImage.dimensions.width,
|
|
height: heroImage.dimensions.height,
|
|
},
|
|
]
|
|
}
|
|
return []
|
|
}
|