feedsmith/dist/namespaces/media/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/media/generate/utils.ts
const generateRating = (rating) => {
	if (!require_utils.isObject(rating)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(rating.value),
		"@scheme": require_utils.generatePlainString(rating.scheme)
	});
};
const generateTitleOrDescription = (titleOrDescription) => {
	if (!require_utils.isObject(titleOrDescription)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(titleOrDescription.value),
		"@type": require_utils.generatePlainString(titleOrDescription.type)
	});
};
const generateThumbnail = (thumbnail) => {
	if (!require_utils.isObject(thumbnail)) return;
	return require_utils.trimObject({
		"@url": require_utils.generatePlainString(thumbnail.url),
		"@height": require_utils.generateNumber(thumbnail.height),
		"@width": require_utils.generateNumber(thumbnail.width),
		"@time": require_utils.generatePlainString(thumbnail.time)
	});
};
const generateCategory = (category) => {
	if (!require_utils.isObject(category)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(category.name),
		"@scheme": require_utils.generatePlainString(category.scheme),
		"@label": require_utils.generatePlainString(category.label)
	});
};
const generateHash = (hash) => {
	if (!require_utils.isObject(hash)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(hash.value),
		"@algo": require_utils.generatePlainString(hash.algo)
	});
};
const generatePlayer = (player) => {
	if (!require_utils.isObject(player)) return;
	return require_utils.trimObject({
		"@url": require_utils.generatePlainString(player.url),
		"@height": require_utils.generateNumber(player.height),
		"@width": require_utils.generateNumber(player.width)
	});
};
const generateCredit = (credit) => {
	if (!require_utils.isObject(credit)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(credit.value),
		"@role": require_utils.generatePlainString(credit.role),
		"@scheme": require_utils.generatePlainString(credit.scheme)
	});
};
const generateCopyright = (copyright) => {
	if (!require_utils.isObject(copyright)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(copyright.value),
		"@url": require_utils.generatePlainString(copyright.url)
	});
};
const generateText = (text) => {
	if (!require_utils.isObject(text)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(text.value),
		"@type": require_utils.generatePlainString(text.type),
		"@lang": require_utils.generatePlainString(text.lang),
		"@start": require_utils.generatePlainString(text.start),
		"@end": require_utils.generatePlainString(text.end)
	});
};
const generateRestriction = (restriction) => {
	if (!require_utils.isObject(restriction)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(restriction.value),
		"@relationship": require_utils.generatePlainString(restriction.relationship),
		"@type": require_utils.generatePlainString(restriction.type)
	});
};
const generateStarRating = (starRating) => {
	if (!require_utils.isObject(starRating)) return;
	return require_utils.trimObject({
		"@average": require_utils.generateNumber(starRating.average),
		"@count": require_utils.generateNumber(starRating.count),
		"@min": require_utils.generateNumber(starRating.min),
		"@max": require_utils.generateNumber(starRating.max)
	});
};
const generateStatistics = (statistics) => {
	if (!require_utils.isObject(statistics)) return;
	return require_utils.trimObject({
		"@views": require_utils.generateNumber(statistics.views),
		"@favorites": require_utils.generateNumber(statistics.favorites)
	});
};
const generateTag = (tag) => {
	if (!require_utils.isObject(tag)) return;
	const name = require_utils.generatePlainString(tag.name);
	if (!name) return;
	return `${name}:${require_utils.generateNumber(tag.weight) ?? 1}`;
};
const generateCommunity = (community) => {
	if (!require_utils.isObject(community)) return;
	return require_utils.trimObject({
		"media:starRating": generateStarRating(community.starRating),
		"media:statistics": generateStatistics(community.statistics),
		"media:tags": require_utils.generateCsvOf(community.tags, generateTag)
	});
};
const generateComments = (comments) => {
	return require_utils.trimObject({ "media:comment": require_utils.trimArray(comments, require_utils.generateCdataString) });
};
const generateResponses = (responses) => {
	return require_utils.trimObject({ "media:response": require_utils.trimArray(responses, require_utils.generateCdataString) });
};
const generateBackLinks = (backLinks) => {
	return require_utils.trimObject({ "media:backLink": require_utils.trimArray(backLinks, require_utils.generateCdataString) });
};
const generateScenes = (scenes) => {
	return require_utils.trimObject({ "media:scene": require_utils.trimArray(scenes, generateScene) });
};
const generateParam = (param) => {
	if (!require_utils.isObject(param)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(param.value),
		"@name": require_utils.generatePlainString(param.name)
	});
};
const generateEmbed = (embed) => {
	if (!require_utils.isObject(embed)) return;
	return require_utils.trimObject({
		"@url": require_utils.generatePlainString(embed.url),
		"@width": require_utils.generateNumber(embed.width),
		"@height": require_utils.generateNumber(embed.height),
		"media:param": require_utils.trimArray(embed.params, generateParam)
	});
};
const generateStatus = (status) => {
	if (!require_utils.isObject(status)) return;
	return require_utils.trimObject({
		"@state": require_utils.generatePlainString(status.state),
		"@reason": require_utils.generatePlainString(status.reason)
	});
};
const generatePrice = (price) => {
	if (!require_utils.isObject(price)) return;
	return require_utils.trimObject({
		"@type": require_utils.generatePlainString(price.type),
		"@info": require_utils.generatePlainString(price.info),
		"@price": require_utils.generateNumber(price.price),
		"@currency": require_utils.generatePlainString(price.currency)
	});
};
const generateLicense = (license) => {
	if (!require_utils.isObject(license)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(license.name),
		"@type": require_utils.generatePlainString(license.type),
		"@href": require_utils.generatePlainString(license.href)
	});
};
const generateSubTitle = (subTitle) => {
	if (!require_utils.isObject(subTitle)) return;
	return require_utils.trimObject({
		"@type": require_utils.generatePlainString(subTitle.type),
		"@lang": require_utils.generatePlainString(subTitle.lang),
		"@href": require_utils.generatePlainString(subTitle.href)
	});
};
const generatePeerLink = (peerLink) => {
	if (!require_utils.isObject(peerLink)) return;
	return require_utils.trimObject({
		"@type": require_utils.generatePlainString(peerLink.type),
		"@href": require_utils.generatePlainString(peerLink.href)
	});
};
const generateRights = (rights) => {
	if (!require_utils.isObject(rights)) return;
	return require_utils.trimObject({ "@status": require_utils.generatePlainString(rights.status) });
};
const generateScene = (scene) => {
	if (!require_utils.isObject(scene)) return;
	return require_utils.trimObject({
		sceneTitle: require_utils.generateCdataString(scene.title),
		sceneDescription: require_utils.generateCdataString(scene.description),
		sceneStartTime: require_utils.generateCdataString(scene.startTime),
		sceneEndTime: require_utils.generateCdataString(scene.endTime)
	});
};
const generateLocation = (location) => {
	if (!require_utils.isObject(location)) return;
	return require_utils.trimObject({
		...require_utils.generateTextOrCdataString(location.description),
		"@start": require_utils.generatePlainString(location.start),
		"@end": require_utils.generatePlainString(location.end),
		"@lat": require_utils.generateNumber(location.lat),
		"@lng": require_utils.generateNumber(location.lng)
	});
};
const generateCommonElements = (elements) => {
	if (!require_utils.isObject(elements)) return;
	return require_utils.trimObject({
		"media:rating": require_utils.trimArray(elements.ratings, generateRating),
		"media:title": generateTitleOrDescription(elements.title),
		"media:description": generateTitleOrDescription(elements.description),
		"media:keywords": require_utils.generateCsvOf(elements.keywords, require_utils.generatePlainString),
		"media:thumbnail": require_utils.trimArray(elements.thumbnails, generateThumbnail),
		"media:category": require_utils.trimArray(elements.categories, generateCategory),
		"media:hash": require_utils.trimArray(elements.hashes, generateHash),
		"media:player": generatePlayer(elements.player),
		"media:credit": require_utils.trimArray(elements.credits, generateCredit),
		"media:copyright": generateCopyright(elements.copyright),
		"media:text": require_utils.trimArray(elements.texts, generateText),
		"media:restriction": require_utils.trimArray(elements.restrictions, generateRestriction),
		"media:community": generateCommunity(elements.community),
		"media:comments": generateComments(elements.comments),
		"media:embed": generateEmbed(elements.embed),
		"media:responses": generateResponses(elements.responses),
		"media:backLinks": generateBackLinks(elements.backLinks),
		"media:status": generateStatus(elements.status),
		"media:price": require_utils.trimArray(elements.prices, generatePrice),
		"media:license": require_utils.trimArray(elements.licenses, generateLicense),
		"media:subTitle": require_utils.trimArray(elements.subTitles, generateSubTitle),
		"media:peerLink": require_utils.trimArray(elements.peerLinks, generatePeerLink),
		"media:location": require_utils.trimArray(elements.locations, generateLocation),
		"media:rights": generateRights(elements.rights),
		"media:scenes": generateScenes(elements.scenes)
	});
};
const generateContent = (content) => {
	if (!require_utils.isObject(content)) return;
	return require_utils.trimObject({
		"@url": require_utils.generatePlainString(content.url),
		"@fileSize": require_utils.generateNumber(content.fileSize),
		"@type": require_utils.generatePlainString(content.type),
		"@medium": require_utils.generatePlainString(content.medium),
		"@isDefault": require_utils.generateYesNoBoolean(content.isDefault),
		"@expression": require_utils.generatePlainString(content.expression),
		"@bitrate": require_utils.generateNumber(content.bitrate),
		"@framerate": require_utils.generateNumber(content.framerate),
		"@samplingrate": require_utils.generateNumber(content.samplingrate),
		"@channels": require_utils.generateNumber(content.channels),
		"@duration": require_utils.generateNumber(content.duration),
		"@height": require_utils.generateNumber(content.height),
		"@width": require_utils.generateNumber(content.width),
		"@lang": require_utils.generatePlainString(content.lang),
		...generateCommonElements(content)
	});
};
const generateGroup = (group) => {
	if (!require_utils.isObject(group)) return;
	return require_utils.trimObject({
		"media:content": require_utils.trimArray(group.contents, generateContent),
		...generateCommonElements(group)
	});
};
const generateItemOrFeed = (itemOrFeed) => {
	if (!require_utils.isObject(itemOrFeed)) return;
	return require_utils.trimObject({
		"media:group": require_utils.generateArrayOrSingular(itemOrFeed.groups, itemOrFeed.group, generateGroup),
		"media:content": require_utils.trimArray(itemOrFeed.contents, generateContent),
		...generateCommonElements(itemOrFeed)
	});
};
//#endregion
exports.generateBackLinks = generateBackLinks;
exports.generateCategory = generateCategory;
exports.generateComments = generateComments;
exports.generateCommonElements = generateCommonElements;
exports.generateCommunity = generateCommunity;
exports.generateContent = generateContent;
exports.generateCopyright = generateCopyright;
exports.generateCredit = generateCredit;
exports.generateEmbed = generateEmbed;
exports.generateGroup = generateGroup;
exports.generateHash = generateHash;
exports.generateItemOrFeed = generateItemOrFeed;
exports.generateLicense = generateLicense;
exports.generateLocation = generateLocation;
exports.generateParam = generateParam;
exports.generatePeerLink = generatePeerLink;
exports.generatePlayer = generatePlayer;
exports.generatePrice = generatePrice;
exports.generateRating = generateRating;
exports.generateResponses = generateResponses;
exports.generateRestriction = generateRestriction;
exports.generateRights = generateRights;
exports.generateScene = generateScene;
exports.generateScenes = generateScenes;
exports.generateStarRating = generateStarRating;
exports.generateStatistics = generateStatistics;
exports.generateStatus = generateStatus;
exports.generateSubTitle = generateSubTitle;
exports.generateTag = generateTag;
exports.generateText = generateText;
exports.generateThumbnail = generateThumbnail;
exports.generateTitleOrDescription = generateTitleOrDescription;