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

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.

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