@kontent-ai/smart-link/dist/es/utils/messageValidation.js

Kontent.ai Smart Link SDK allowing to automatically inject [smart links](https://docs.kontent.ai/tutorials/develop-apps/build-strong-foundation/set-up-editing-from-preview#a-using-smart-links) to Kontent.ai according to manually specified [HTML data attri

import { logGroupCollapsed, logGroupEnd, logInfo } from '../lib/Logger';
import { InsertPositionPlacement, } from '../lib/IFrameCommunicatorTypes';
const validateConfigurationDataAttributes = (data, configurationDataAttributes) => {
    const languageCodename = data.parsed.languageCodename ?? configurationDataAttributes.languageCodename;
    const projectId = data.parsed.environmentId ?? configurationDataAttributes.environmentId;
    if (!languageCodename || !projectId) {
        const missing = [
            ...(!languageCodename ? ['languageCodename'] : []),
            ...(!projectId ? ['environmentId'] : []),
        ];
        return { success: false, missing: missing };
    }
    return { success: true, data: { languageCodename, projectId } };
};
function validateContentItemClickEditMessageData(data, configurationDataAttributes) {
    const configData = validateConfigurationDataAttributes(data, configurationDataAttributes);
    if (!data.parsed.itemId || !configData.success) {
        return {
            success: false,
            missing: [
                ...(!data.parsed.itemId ? ['itemId'] : []),
                ...(configData.success ? [] : configData.missing),
            ],
        };
    }
    return {
        success: true,
        data: {
            languageCodename: configData.data.languageCodename,
            projectId: configData.data.projectId,
            itemId: data.parsed.itemId,
        },
    };
}
function validateElementClickMessageData(data, configurationDataAttributes) {
    const parseItem = validateContentItemClickEditMessageData(data, configurationDataAttributes);
    if (!data.parsed.elementCodename || !parseItem.success) {
        return { success: false, missing: ['elementCodename', ...(parseItem.success ? [] : parseItem.missing)] };
    }
    return {
        success: true,
        data: {
            ...parseItem.data,
            elementCodename: data.parsed.elementCodename,
            contentComponentId: data.parsed.contentComponentId ?? undefined,
        },
    };
}
function validateContentComponentClickMessageData(data, configurationDataAttributes) {
    const parseItem = validateContentItemClickEditMessageData(data, configurationDataAttributes);
    if (!data.parsed.contentComponentId || !parseItem.success) {
        return { success: false, missing: ['contentComponentId', ...(parseItem.success ? [] : parseItem.missing)] };
    }
    return {
        success: true,
        data: {
            ...parseItem.data,
            contentComponentId: data.parsed.contentComponentId,
        },
    };
}
export const validateEditButtonMessageData = (data, configuration) => {
    const getValidationResult = () => {
        if ('elementCodename' in data.parsed) {
            return {
                type: 'element',
                validationResult: validateElementClickMessageData(data, configuration.defaultDataAttributes),
            };
        }
        if ('contentComponentId' in data.parsed) {
            return {
                type: 'contentComponent',
                validationResult: validateContentComponentClickMessageData(data, configuration.defaultDataAttributes),
            };
        }
        return {
            type: 'contentItem',
            validationResult: validateContentItemClickEditMessageData(data, configuration.defaultDataAttributes),
        };
    };
    const { type, validationResult } = getValidationResult();
    if (!validationResult.success) {
        printDebugData(data.debugData, '[KSL]: Parsing edit button data attributes failed');
        return {
            type: 'error',
            missing: validationResult.missing,
        };
    }
    if (configuration.debug) {
        printDebugData(data.debugData, '[KSL]: Parsed edit button data attributes');
    }
    if (type === 'element') {
        return {
            type: 'element',
            data: validationResult.data,
        };
    }
    if (type === 'contentComponent') {
        return {
            type: 'contentComponent',
            data: validationResult.data,
        };
    }
    return {
        type: 'contentItem',
        data: validationResult.data,
    };
};
const validatePlacement = (data) => {
    const insertPosition = getPlacement(data.parsed.placement);
    if ((insertPosition === InsertPositionPlacement.After || insertPosition === InsertPositionPlacement.Before) &&
        !data.parsed.targetId) {
        return { success: false, missing: ['targetId'] };
    }
    return { success: true, data: { placement: insertPosition, targetId: data.parsed.targetId ?? undefined } };
};
const getPlacement = (placement) => {
    switch (placement) {
        case 'after':
            return InsertPositionPlacement.After;
        case 'before':
            return InsertPositionPlacement.Before;
        case 'start':
            return InsertPositionPlacement.Start;
        case 'end':
        default:
            return InsertPositionPlacement.End;
    }
};
export function validateAddInitialMessageData(data, configuration) {
    const configData = validateConfigurationDataAttributes(data, configuration.defaultDataAttributes);
    const placement = validatePlacement(data);
    if (!data.parsed.itemId || !data.parsed.elementCodename || !placement.success || !configData.success) {
        printDebugData(data.debugData, '[KSL]: Parsing add button data attributes failed');
        return {
            success: false,
            missing: [
                ...(!data.parsed.itemId ? ['itemId'] : []),
                ...(!data.parsed.elementCodename ? ['elementCodename'] : []),
                ...(placement.success ? [] : placement.missing),
                ...(configData.success ? [] : configData.missing),
            ],
        };
    }
    if (configuration.debug) {
        printDebugData(data.debugData, '[KSL]: Parsed add button data attributes');
    }
    return {
        success: true,
        data: {
            projectId: configData.data.projectId,
            languageCodename: configData.data.languageCodename,
            itemId: data.parsed.itemId,
            contentComponentId: data.parsed.contentComponentId ?? undefined,
            insertPosition: placement.data,
            elementCodename: data.parsed.elementCodename,
        },
    };
}
const printDebugData = (debugData, message) => {
    logGroupCollapsed(message);
    debugData.forEach((item) => {
        logGroupCollapsed(item.element);
        if (item.parsedAttributes.length > 0) {
            logInfo('Resolved attributes:');
            item.parsedAttributes.forEach((attr) => {
                logInfo(`${attr.token}: ${attr.dataAttribute}: ${attr.value}`);
            });
        }
        if (item.skippedAttributes.length > 0) {
            logInfo('Parsed Kontent.ai attributes:');
            item.skippedAttributes.forEach((attr) => {
                logInfo(`${attr.dataAttribute}: ${attr.value}`);
            });
        }
        logGroupEnd();
    });
    logGroupEnd();
};
//# sourceMappingURL=messageValidation.js.map