@allmaps/iiif-parser/dist/lib/convert.js

Allmaps IIIF parser

import { z } from 'zod';
export const LanguageString3Schema = z.record(z.string(), z.string().array());
export const MetadataStringItem3Schema = z.object({
    label: LanguageString3Schema.optional(),
    value: LanguageString3Schema.optional()
});
export function ensureArray(val) {
    if (val) {
        return Array.isArray(val) ? val : [val];
    }
}
export function parseVersion2String(str) {
    // TODO: use type guards!
    if (typeof str === 'string') {
        return {
            none: [str]
        };
    }
    else if (Array.isArray(str)) {
        let strings = {};
        str.forEach((item) => {
            if (typeof item === 'string') {
                if (!strings['none']) {
                    strings['none'] = [];
                }
                strings['none'].push(item);
            }
            else if (typeof item === 'object') {
                // TODO: find test input data for this scenario
                strings = { ...strings, ...parseVersion2String(item) };
            }
            else {
                throw new Error('Unable to parse string');
            }
        });
        return strings;
    }
    else if (str && typeof str === 'object') {
        str;
        const language = str['@language'] || 'none';
        const valueOrValues = str['@value'] || '';
        return {
            [language]: Array.isArray(valueOrValues) ? valueOrValues : [valueOrValues]
        };
    }
}
export function parseVersion3String(str) {
    if (!str) {
        return;
    }
    const parsedStr = {};
    for (const language in str) {
        parsedStr[language] = str[language];
    }
    return parsedStr;
}
export function parseMetadata2Item(item) {
    if (item) {
        const label = parseVersion2String(item.label);
        const value = parseVersion2String(item.value);
        if (label && value) {
            return { label, value };
        }
    }
}
export function parseMetadata3Item(item) {
    if (item) {
        const label = parseVersion3String(item.label);
        const value = parseVersion3String(item.value);
        if (label && value) {
            return { label, value };
        }
    }
}
export function isValidMetadataItem(item) {
    return item !== undefined;
}
export function parseVersion2Metadata(metadata) {
    if (Array.isArray(metadata)) {
        if (metadata.length === 0) {
            return undefined;
        }
        return metadata.map(parseMetadata2Item).filter(isValidMetadataItem);
    }
    else if (!metadata) {
        return undefined;
    }
    else {
        throw new Error('Unable to parse metadata');
    }
}
export function parseVersion3Metadata(metadata) {
    if (Array.isArray(metadata)) {
        if (metadata.length === 0) {
            return undefined;
        }
        return metadata.map(parseMetadata3Item).filter(isValidMetadataItem);
    }
    else if (!metadata) {
        return undefined;
    }
    else {
        throw new Error('Unable to parse metadata');
    }
}
export function parseVersion2Attribution(attribution) {
    if (attribution) {
        if (typeof attribution === 'string') {
            return {
                label: {
                    none: ['Attribution']
                },
                value: {
                    none: [attribution]
                }
            };
        }
        else {
            const value = parseVersion2String(attribution);
            if (value) {
                return {
                    label: {
                        none: ['Attribution']
                    },
                    value
                };
            }
        }
    }
}
export function parseVersion2Thumbnail(thumbnail2) {
    return thumbnail2?.map((thumbnail) => {
        if (typeof thumbnail === 'string') {
            return {
                id: thumbnail
            };
        }
        else {
            return {
                id: thumbnail['@id'],
                type: thumbnail['@type'],
                format: thumbnail.format,
                width: thumbnail.width,
                height: thumbnail.height
            };
        }
    });
}
export function parseVersion2Rendering(rendering2) {
    return rendering2?.map((rendering) => ({
        id: rendering['@id'],
        type: rendering['@type'],
        label: parseVersion2String(rendering.label),
        format: rendering.format
    }));
}
export function parseVersion2Related(related) {
    if (related) {
        if (typeof related === 'string') {
            return [
                {
                    id: related
                }
            ];
        }
        else if (Array.isArray(related)) {
            return related.map((item) => {
                if (typeof item === 'string') {
                    return {
                        id: item
                    };
                }
                else {
                    return {
                        id: item['@id'],
                        label: parseVersion2String(item.label),
                        format: item.format
                    };
                }
            });
        }
        else {
            return [
                {
                    id: related['@id'],
                    label: parseVersion2String(related.label),
                    format: related.format
                }
            ];
        }
    }
}