feedsmith/dist/namespaces/podcast/generate/utils.js

Fast, all‑in‑one feed parser and generator for RSS, Atom, RDF, and JSON Feed, with support for Podcast, iTunes, Dublin Core, and OPML files.

import { generateArrayOrSingular, generateBoolean, generateCdataString, generateNumber, generatePlainString, generateRfc3339Date, generateRfc822Date, generateSingularOrArray, generateTextOrCdataString, generateYesNoBoolean, isObject, trimArray, trimObject } from "../../../common/utils.js";
//#region src/namespaces/podcast/generate/utils.ts
const generateBaseItem = (baseItem) => {
	if (!isObject(baseItem)) return;
	return trimObject({
		"podcast:transcript": trimArray(baseItem.transcripts, generateTranscript),
		"podcast:chapters": generateChapters(baseItem.chapters),
		"podcast:soundbite": trimArray(baseItem.soundbites, generateSoundbite),
		"podcast:person": trimArray(baseItem.persons, generatePerson),
		"podcast:location": generateArrayOrSingular(baseItem.locations, baseItem.location, generateLocation),
		"podcast:season": generateSeason(baseItem.season),
		"podcast:episode": generateEpisode(baseItem.episode),
		"podcast:license": generateLicense(baseItem.license),
		"podcast:alternateEnclosure": trimArray(baseItem.alternateEnclosures, generateAlternateEnclosure),
		"podcast:value": generateArrayOrSingular(baseItem.values, baseItem.value, generateValue),
		"podcast:image": trimArray(baseItem.images, generateImage),
		"podcast:socialInteract": trimArray(baseItem.socialInteracts, generateSocialInteract),
		"podcast:txt": trimArray(baseItem.txts, generateTxt),
		"podcast:chat": generateSingularOrArray(baseItem.chat, baseItem.chats, generateChat)
	});
};
const generateTranscript = (transcript) => {
	if (!isObject(transcript)) return;
	return trimObject({
		"@url": generatePlainString(transcript.url),
		"@type": generatePlainString(transcript.type),
		"@language": generatePlainString(transcript.language),
		"@rel": generatePlainString(transcript.rel)
	});
};
const generateLocked = (locked) => {
	if (!isObject(locked)) return;
	return trimObject({
		"#text": generateYesNoBoolean(locked.value),
		"@owner": generatePlainString(locked.owner)
	});
};
const generateFunding = (funding) => {
	if (!isObject(funding)) return;
	return trimObject({
		...generateTextOrCdataString(funding.display),
		"@url": generatePlainString(funding.url)
	});
};
const generateChapters = (chapters) => {
	if (!isObject(chapters)) return;
	return trimObject({
		"@url": generatePlainString(chapters.url),
		"@type": generatePlainString(chapters.type)
	});
};
const generateSoundbite = (soundbite) => {
	if (!isObject(soundbite)) return;
	return trimObject({
		...generateTextOrCdataString(soundbite.display),
		"@startTime": generateNumber(soundbite.startTime),
		"@duration": generateNumber(soundbite.duration)
	});
};
const generatePerson = (person) => {
	if (!isObject(person)) return;
	return trimObject({
		...generateTextOrCdataString(person.display),
		"@role": generatePlainString(person.role),
		"@group": generatePlainString(person.group),
		"@img": generatePlainString(person.img),
		"@href": generatePlainString(person.href)
	});
};
const generateLocation = (location) => {
	if (!isObject(location)) return;
	return trimObject({
		...generateTextOrCdataString(location.display),
		"@rel": generatePlainString(location.rel),
		"@geo": generatePlainString(location.geo),
		"@osm": generatePlainString(location.osm),
		"@country": generatePlainString(location.country)
	});
};
const generateSeason = (season) => {
	if (!isObject(season)) return;
	return trimObject({
		"#text": generateNumber(season.number),
		"@name": generatePlainString(season.name)
	});
};
const generateEpisode = (episode) => {
	if (!isObject(episode)) return;
	return trimObject({
		"#text": generateNumber(episode.number),
		"@display": generatePlainString(episode.display)
	});
};
const generateTrailer = (trailer) => {
	if (!isObject(trailer)) return;
	return trimObject({
		...generateTextOrCdataString(trailer.display),
		"@url": generatePlainString(trailer.url),
		"@pubdate": generateRfc822Date(trailer.pubDate),
		"@length": generateNumber(trailer.length),
		"@type": generatePlainString(trailer.type),
		"@season": generateNumber(trailer.season)
	});
};
const generateLicense = (license) => {
	if (!isObject(license)) return;
	return trimObject({
		...generateTextOrCdataString(license.display),
		"@url": generatePlainString(license.url)
	});
};
const generateSource = (source) => {
	if (!isObject(source)) return;
	return trimObject({
		"@uri": generatePlainString(source.uri),
		"@contentType": generatePlainString(source.contentType)
	});
};
const generateIntegrity = (integrity) => {
	if (!isObject(integrity)) return;
	return trimObject({
		"@type": generatePlainString(integrity.type),
		"@value": generatePlainString(integrity.value)
	});
};
const generateAlternateEnclosure = (alternateEnclosure) => {
	if (!isObject(alternateEnclosure)) return;
	return trimObject({
		"@type": generatePlainString(alternateEnclosure.type),
		"@length": generateNumber(alternateEnclosure.length),
		"@bitrate": generateNumber(alternateEnclosure.bitrate),
		"@height": generateNumber(alternateEnclosure.height),
		"@lang": generatePlainString(alternateEnclosure.lang),
		"@title": generatePlainString(alternateEnclosure.title),
		"@rel": generatePlainString(alternateEnclosure.rel),
		"@codecs": generatePlainString(alternateEnclosure.codecs),
		"@default": generateBoolean(alternateEnclosure.default),
		"podcast:source": trimArray(alternateEnclosure.sources, generateSource),
		"podcast:integrity": generateIntegrity(alternateEnclosure.integrity)
	});
};
const generateValueRecipient = (valueRecipient) => {
	if (!isObject(valueRecipient)) return;
	return trimObject({
		"@name": generatePlainString(valueRecipient.name),
		"@customKey": generatePlainString(valueRecipient.customKey),
		"@customValue": generatePlainString(valueRecipient.customValue),
		"@type": generatePlainString(valueRecipient.type),
		"@address": generatePlainString(valueRecipient.address),
		"@split": generateNumber(valueRecipient.split),
		"@fee": generateBoolean(valueRecipient.fee)
	});
};
const generateValueTimeSplit = (valueTimeSplit) => {
	if (!isObject(valueTimeSplit)) return;
	return trimObject({
		"@startTime": generateNumber(valueTimeSplit.startTime),
		"@duration": generateNumber(valueTimeSplit.duration),
		"@remoteStartTime": generateNumber(valueTimeSplit.remoteStartTime),
		"@remotePercentage": generateNumber(valueTimeSplit.remotePercentage),
		"podcast:remoteItem": generateRemoteItem(valueTimeSplit.remoteItem),
		"podcast:valueRecipient": trimArray(valueTimeSplit.valueRecipients, generateValueRecipient)
	});
};
const generateValue = (value) => {
	if (!isObject(value)) return;
	return trimObject({
		"@type": generatePlainString(value.type),
		"@method": generatePlainString(value.method),
		"@suggested": generateNumber(value.suggested),
		"podcast:valueRecipient": trimArray(value.valueRecipients, generateValueRecipient),
		"podcast:valueTimeSplit": trimArray(value.valueTimeSplits, generateValueTimeSplit)
	});
};
const generateImage = (image) => {
	if (!isObject(image)) return;
	return trimObject({
		"@href": generatePlainString(image.href),
		"@alt": generatePlainString(image.alt),
		"@aspect-ratio": generatePlainString(image.aspectRatio),
		"@width": generateNumber(image.width),
		"@height": generateNumber(image.height),
		"@type": generatePlainString(image.type),
		"@purpose": generatePlainString(image.purpose)
	});
};
const generateContentLink = (contentLink) => {
	if (!isObject(contentLink)) return;
	return trimObject({
		...generateTextOrCdataString(contentLink.display),
		"@href": generatePlainString(contentLink.href)
	});
};
const generateLiveItem = (liveItem) => {
	if (!isObject(liveItem)) return;
	return trimObject({
		...generateBaseItem(liveItem),
		"@status": generatePlainString(liveItem.status),
		"@start": generateRfc3339Date(liveItem.start),
		"@end": generateRfc3339Date(liveItem.end),
		"podcast:contentLink": trimArray(liveItem.contentLinks, generateContentLink)
	});
};
const generateSocialInteract = (socialInteract) => {
	if (!isObject(socialInteract)) return;
	return trimObject({
		"@uri": generatePlainString(socialInteract.uri),
		"@protocol": generatePlainString(socialInteract.protocol),
		"@accountId": generatePlainString(socialInteract.accountId),
		"@accountUrl": generatePlainString(socialInteract.accountUrl),
		"@priority": generateNumber(socialInteract.priority)
	});
};
const generateChat = (chat) => {
	if (!isObject(chat)) return;
	return trimObject({
		"@server": generatePlainString(chat.server),
		"@protocol": generatePlainString(chat.protocol),
		"@accountId": generatePlainString(chat.accountId),
		"@space": generatePlainString(chat.space)
	});
};
const generateBlock = (block) => {
	if (!isObject(block)) return;
	return trimObject({
		"#text": generateYesNoBoolean(block.value),
		"@id": generatePlainString(block.id)
	});
};
const generateTxt = (txt) => {
	if (!isObject(txt)) return;
	return trimObject({
		...generateTextOrCdataString(txt.display),
		"@purpose": generatePlainString(txt.purpose)
	});
};
const generateRemoteItem = (remoteItem) => {
	if (!isObject(remoteItem)) return;
	return trimObject({
		"@feedGuid": generatePlainString(remoteItem.feedGuid),
		"@feedUrl": generatePlainString(remoteItem.feedUrl),
		"@itemGuid": generatePlainString(remoteItem.itemGuid),
		"@medium": generatePlainString(remoteItem.medium),
		"@title": generatePlainString(remoteItem.title)
	});
};
const generatePodroll = (podroll) => {
	if (!isObject(podroll)) return;
	return trimObject({ "podcast:remoteItem": trimArray(podroll.remoteItems, generateRemoteItem) });
};
const generateUpdateFrequency = (updateFrequency) => {
	if (!isObject(updateFrequency)) return;
	return trimObject({
		...generateTextOrCdataString(updateFrequency.display),
		"@complete": generateBoolean(updateFrequency.complete),
		"@dtstart": generateRfc3339Date(updateFrequency.dtstart),
		"@rrule": generatePlainString(updateFrequency.rrule)
	});
};
const generatePodping = (podping) => {
	if (!isObject(podping)) return;
	return trimObject({ "@usesPodping": generateBoolean(podping.usesPodping) });
};
const generatePublisher = (publisher) => {
	if (!isObject(publisher)) return;
	return trimObject({ "podcast:remoteItem": generateRemoteItem(publisher.remoteItem) });
};
const generateItem = (item) => {
	if (!isObject(item)) return;
	return generateBaseItem(item);
};
const generateFeed = (feed) => {
	if (!isObject(feed)) return;
	return trimObject({
		"podcast:locked": generateLocked(feed.locked),
		"podcast:funding": trimArray(feed.fundings, generateFunding),
		"podcast:person": trimArray(feed.persons, generatePerson),
		"podcast:location": generateArrayOrSingular(feed.locations, feed.location, generateLocation),
		"podcast:trailer": trimArray(feed.trailers, generateTrailer),
		"podcast:license": generateLicense(feed.license),
		"podcast:guid": generateCdataString(feed.guid),
		"podcast:value": generateArrayOrSingular(feed.values, feed.value, generateValue),
		"podcast:medium": generateCdataString(feed.medium),
		"podcast:image": trimArray(feed.images, generateImage),
		"podcast:liveItem": trimArray(feed.liveItems, generateLiveItem),
		"podcast:block": trimArray(feed.blocks, generateBlock),
		"podcast:txt": trimArray(feed.txts, generateTxt),
		"podcast:remoteItem": trimArray(feed.remoteItems, generateRemoteItem),
		"podcast:podroll": generatePodroll(feed.podroll),
		"podcast:updateFrequency": generateUpdateFrequency(feed.updateFrequency),
		"podcast:podping": generatePodping(feed.podping),
		"podcast:chat": generateSingularOrArray(feed.chat, feed.chats, generateChat),
		"podcast:publisher": generatePublisher(feed.publisher)
	});
};
//#endregion
export { generateAlternateEnclosure, generateBaseItem, generateBlock, generateChapters, generateChat, generateContentLink, generateEpisode, generateFeed, generateFunding, generateImage, generateIntegrity, generateItem, generateLicense, generateLiveItem, generateLocation, generateLocked, generatePerson, generatePodping, generatePodroll, generatePublisher, generateRemoteItem, generateSeason, generateSocialInteract, generateSoundbite, generateSource, generateTrailer, generateTranscript, generateTxt, generateUpdateFrequency, generateValue, generateValueRecipient, generateValueTimeSplit };