license-utilities.js

/** @typedef {{BY?: boolean, NC?: boolean, ND?: boolean, SA?: boolean}} LicenseAttributes */

/** @typedef {('CC0 1.0'|'CC BY 4.0'|'CC BY-SA 4.0'|'CC BY-NC 4.0'|'CC BY-ND 4.0'|'CC BY-NC-ND 4.0'|'CC BY-NC-SA 4.0')} ShortLicenseName
 */
/** @typedef {('CC0 1.0 Universal'|'Attribution 4.0 International'|'Attribution-ShareAlike 4.0 International'|'Attribution-NonCommercial-ShareAlike 4.0 International'|'Attribution-NonCommercial-NoDerivatives 4.0 International'|'Attribution-NoDerivatives 4.0 International')} FullLicenseName
 */
import { LICENSES } from './licenses'
const CC0Attributes = LICENSES.CC0.ATTRIBUTES
const CCBYAttributes = LICENSES.CC_BY.ATTRIBUTES
const defaultAttributes = { BY: undefined, NC: undefined, ND: undefined, SA: undefined }

const shortToSlug = {
    'CC0 1.0': 'CC0',
    'CC BY 4.0': 'CC_BY',
    'CC BY-ND 4.0': 'CC_BY_ND',
    'CC BY-SA 4.0': 'CC_BY_SA',
    'CC BY-NC 4.0': 'CC_BY_NC',
    'CC BY-NC-ND 4.0': 'CC_BY_NC_ND',
    'CC BY-NC-SA 4.0': 'CC_BY_NC_SA'
}

/**
 * Converts the short license name into slug that can be used to look up
 * license information in the LICENSES object
 * @param short
 * @returns {string}
 */
const slugFromShort = (short) => {
    return shortToSlug[short]
}

/**
 * Convert license attributes object to short license name
 * @param {LicenseAttributes} attr
 * @returns {ShortLicenseName}
 */
function attrToShort(attr) {
    if (attr.BY === undefined) return undefined
    if (!attr.BY) { return 'CC0 1.0' }
    let base = 'CC BY'
    if (attr.NC) { base += '-NC' }
    if (!attr.ND && attr.SA) {
        base += '-SA'
    } else if (attr.ND) {
        base += '-ND'
    }
    base += ' 4.0'
    return base
}

/**
 * Convert license attributes object to full license name
 * @param {LicenseAttributes} attr
 * @returns {string|null}
 */
function attrToFull(attr) {
    const slug = slugFromShort(attrToShort(attr))
    if (!slug) return null
    return LICENSES[slug].FULL
}

const chooserRef = '?ref=chooser-v1'

/**
 * Returns url to license from short license name with version number (eg. 'CC BY 4.0')
 * @param {LicenseAttributes} attr license attributes object
 * @param {'web'|'print'} mode?  (?ref=chooser-v1, target and rel are added to the end of the link if mode is web)
 * @returns {string} url of the license information page
 */
function licenseURL(attr, mode = 'web') {
    if (attr.BY === undefined) throw new Error('Cannot return URL when BY attribute is undefined')
    const slug = slugFromShort(attrToShort(attr))
    const url = LICENSES[slug].URL
    const linkRef = mode === 'web' ? chooserRef : ''
    return `${url}${linkRef}`
}

/**
 * Convert short license name to licence slug ('CC BY 4.0' -> 'cc-by')
 * @param {ShortLicenseName} shortLicenseName
 * @returns {string}
 */
function licenseSlug(shortLicenseName) {
    const currentLicense = Object.values(LICENSES).find(license => {
        return license.SHORT === shortLicenseName
    })
    if (!currentLicense) throw new Error(`Cannot create slug from string "${shortLicenseName}"`)
    return currentLicense.SLUG
}

/**
 * Convert license attributes object to an array of icon names
 * @param {LicenseAttributes} licenseAttributes
 * @returns {string[]} Array with slugified names of icons, eg. ['cc', 'by']
 */
function licenseIconsArr(licenseAttributes) {
    if (!licenseAttributes.BY) {
        return ['zero']
    }
    const iconsArray = []
    for (const key in licenseAttributes) {
        if (licenseAttributes[key]) {
            iconsArray.push(key.toLowerCase())
        }
    }
    return iconsArray
}

function updateVisibleEnabledStatus(stepStatusData) {
    let visible
    let enabled
    let stepsDisabledDue = ''
    if (stepStatusData.FS) {
        // User will select from the dropdown
        if (stepStatusData.BY === false) {
            // User selected a license from the dropdown a CC0 license
            // First step, dropdown and attribution details should be visible and enabled
            visible = ['FS', 'DD', 'CW', 'AD']
            enabled = ['FS', 'DD', 'CW', 'AD']
            stepsDisabledDue = 'CC0'
        } else {
            // User hasn't selected anything yet, or selected a BY license
            // First step, dropdown and attribution details should be visible and enabled
            visible = ['FS', 'DD', 'AD']
            enabled = ['FS', 'DD', 'AD']
        }
    } else {
        // User uses the stepper for license selection
        if (stepStatusData.BY === false) {
            // User selects a CC0 license
            visible = ['FS', 'BY', 'NC', 'ND', 'SA', 'CW', 'AD']
            enabled = ['FS', 'BY', 'CW', 'AD']
            stepsDisabledDue = 'CC0'
        } else if (stepStatusData.ND) {
            // User selects an ND license: SA step is disabled
            visible = ['FS', 'BY', 'NC', 'ND', 'SA', 'AD']
            enabled = ['FS', 'BY', 'NC', 'ND', 'AD']
            stepsDisabledDue = 'ND'
        } else {
            // User selects a non-ND BY license from the stepper
            visible = ['AL', 'FS', 'BY', 'NC', 'ND', 'SA', 'AD']
            enabled = ['AL', 'FS', 'BY', 'NC', 'ND', 'SA', 'AD']
        }
    }
    return { visible, enabled, stepsDisabledDue }
}

const CC_NAMESPACE = {
    NAME: 'xmlns:cc',
    URI: 'http://creativecommons.org/ns#'
}
const DCT_NAMESPACE = {
    NAME: 'xmlns:dct',
    URI: 'http://purl.org/dc/terms/'
}
const ICON_STYLE = 'height:22px!important;margin-left:3px;vertical-align:text-bottom;'
const ICON_BASE_URL = 'https://mirrors.creativecommons.org/presskit/icons'

/**
 * Generate html for creator:
 * 1. If the creator name is blank, even if creator link is provided, return a blank string
 * 2. If only creator name is provided, return a span with proper metadata
 * 3. If both creator name and URL are provided, returns an 'a' element with proper data and metadata
 * @param {string} creatorName
 * @param {string} creatorProfileUrl
 * @returns {string}
 */
function generateCreatorCode(creatorName, creatorProfileUrl) {
    if (!creatorName) {
        return ''
    }
    if (creatorProfileUrl) {
        const absoluteUrl = creatorProfileUrl.startsWith('http') ? creatorProfileUrl : `http://${creatorProfileUrl}`
        const linkMeta = 'rel="cc:attributionURL dct:creator" property="cc:attributionName"'
        return `<a ${linkMeta} href="${absoluteUrl}">${creatorName}</a>`
    } else {
        return `<span property="cc:attributionName">${creatorName}</span>`
    }
}

/**
 * Generate html for work title:
 *
 * 1. If the user has not provided a work url:
 *  a. Title is default: return title
 *  b. Title is provided: return span with `dct:title` property
 *
 * 2. If the user has provided a work url:
 *  Convert any url into absolute url by adding 'http://' to the beginning
 *  Return anchor with 'dct:title' attribute if title is not default
 *
 * @param {string} title
 * @param {string} workUrl
 * @param {Boolean} isTitleDefault - true if the user hasn't provided a title, false otherwise
 * @returns {string}
 */
function generateWorkCode(title, workUrl, isTitleDefault) {
    if (isTitleDefault && !workUrl) {
        return title
    }

    const titleMeta = 'property="dct:title"'
    if (!workUrl) {
        return `<span ${titleMeta}>${title}</span>`
    }

    const absoluteUrl = workUrl.startsWith('http') ? workUrl : `http://${workUrl}`
    return `<a ${isTitleDefault ? '' : titleMeta} rel="cc:attributionURL" href="${absoluteUrl}">${title}</a>`
}

/**
 * Generates the html for the rich text license information, including license name,
 * link to the license deed, and license icons
 * @param {array} licenseIcons
 * @param {string} licenseUrl
 * @param {ShortLicenseName|FullLicenseName} licenseName
 * @returns {string} HTML code for the license
 */
function generateLicenseLink(licenseIcons, licenseUrl, licenseName) {
    const iconStyle = `style="${ICON_STYLE}"`
    const assetPathRef = '?ref=chooser-v1'
    const iconSrc = (attr) => `${ICON_BASE_URL}/${attr.toLowerCase()}.svg${assetPathRef}`
    const icons = licenseIcons
        .map(attr => `<img ${iconStyle} src="${iconSrc(attr)}">`).join('')

    const linkHref = `href="${licenseUrl}${assetPathRef}"`
    const linkAttributes = 'target="_blank" rel="license noopener noreferrer"'
    const linkStyle = 'style="display:inline-block;"'
    return `<a ${linkHref} ${linkAttributes} ${linkStyle}>${licenseName}${icons}</a>`
}

/**
 * Generate data for use in attribution HTML through i18n
 * @param attributionDetails
 * @param {ShortLicenseName} shortLicenseName
 * @param {Boolean} useFullName - Should the license name be full (short by default)
 * @param {Boolean} isTitleDefault
 * @returns {{creator: string, work: string, license: string}}
 */
function generateHTML(attributionDetails, shortLicenseName, useFullName = false, isTitleDefault = true) {
    const data = {}
    const { creatorName, creatorProfileUrl, workUrl, workTitle } = attributionDetails

    const licenseSlug = slugFromShort(shortLicenseName)
    const { ICONS: icons, URL: url, FULL: fullLicenseName } = LICENSES[licenseSlug]
    const licenseName = useFullName ? fullLicenseName : shortLicenseName

    data.license = generateLicenseLink(icons, url, licenseName)
    data.creator = generateCreatorCode(creatorName, creatorProfileUrl)
    data.work = generateWorkCode(workTitle, workUrl, isTitleDefault)
    return data
}

export {
    defaultAttributes, CC0Attributes, CCBYAttributes, attrToShort, slugFromShort,
    attrToFull, licenseURL, chooserRef, licenseSlug, licenseIconsArr, generateHTML, updateVisibleEnabledStatus,
    CC_NAMESPACE, DCT_NAMESPACE, LICENSES, ICON_STYLE, ICON_BASE_URL
}