@kontent-ai/model-generator/dist/core/element.utils.js

This utility generates strongly-typed models for Delivery JS SDK, Migration toolkit or just general scripting to improve the experience when referencing Kontent.ai related objects.

import { P, match } from "ts-pattern";
import { isNotUndefined } from "./core.utils.js";
export function getFlattenedElements(data) {
    return data.elements
        .flatMap((element) => {
        return match(element)
            .returnType()
            .with({ type: "snippet" }, (snippetElement) => {
            const snippet = data.snippets.find((snippet) => snippet.id === snippetElement.snippet.id);
            if (!snippet) {
                throw new Error(`Could not find snippet with id '${snippetElement.snippet.id}'`);
            }
            return snippet.elements.map((snippetElement) => {
                return {
                    element: snippetElement,
                    fromSnippet: snippet,
                };
            });
        })
            .otherwise(() => {
            return {
                element: element,
                fromSnippet: undefined,
            };
        });
    })
        .map((element) => {
        return getFlattenedElement(element, data.taxonomies, data.types);
    })
        .filter(isNotUndefined)
        .filter((element) => {
        return element.type !== "guidelines";
    });
}
function getFlattenedElement(wrapper, taxonomies, types) {
    if (!(wrapper.element.codename && wrapper.element.id)) {
        return undefined;
    }
    return {
        title: getElementTitle(wrapper.element, taxonomies),
        codename: wrapper.element.codename,
        id: wrapper.element.id,
        type: wrapper.element.type,
        isRequired: isElementRequired(wrapper.element),
        guidelines: getElementGuidelines(wrapper.element),
        externalId: wrapper.element.external_id,
        originalElement: wrapper.element,
        allowedContentTypes: extractLinkedItemsAllowedTypes(wrapper.element, types),
        assignedTaxonomy: extractTaxonomy(wrapper.element, taxonomies),
        fromSnippet: wrapper.fromSnippet,
        multipleChoiceOptions: extractMultipleChoiceOptions(wrapper.element),
        isElementWithProperty: match(wrapper.element.type)
            .returnType()
            .with("guidelines", () => false)
            .otherwise(() => true),
    };
}
function isElementRequired(element) {
    return match(element)
        .returnType()
        .with({ is_required: true }, () => true)
        .otherwise(() => false);
}
function getElementGuidelines(element) {
    return match(element)
        .returnType()
        .with({ guidelines: P.string }, (element) => element.guidelines)
        .otherwise(() => undefined);
}
function getElementTitle(element, taxonomies) {
    return match(element)
        .returnType()
        .with({ type: "taxonomy" }, (taxonomyElement) => {
        const taxonomyGroupId = taxonomyElement.taxonomy_group.id;
        if (!taxonomyGroupId) {
            return element.type;
        }
        const taxonomy = taxonomies.find((m) => m.id === taxonomyGroupId);
        return taxonomy?.name ?? element.type;
    })
        .with({ name: P.string }, (element) => element.name)
        .otherwise(() => "invalidTitle");
}
function extractLinkedItemsAllowedTypes(element, types) {
    const allowedTypeIds = match(element)
        .returnType()
        .with({ type: P.union("modular_content", "subpages", "rich_text") }, (elementWithAllowedContentTypes) => {
        return elementWithAllowedContentTypes.allowed_content_types?.map((m) => m.id).filter(isNotUndefined) ?? [];
    })
        .otherwise(() => []);
    return allowedTypeIds.map((id) => types.find((m) => m.id === id)).filter(isNotUndefined);
}
function extractMultipleChoiceOptions(element) {
    return match(element)
        .returnType()
        .with({ type: "multiple_choice" }, (multipleChoiceElement) => {
        return multipleChoiceElement.options.map((option) => {
            return {
                codename: option.codename ?? "",
                name: option.name,
            };
        });
    })
        .otherwise(() => undefined);
}
function extractTaxonomy(element, taxonomies) {
    return match(element)
        .returnType()
        .with({ type: "taxonomy" }, (taxonomyElement) => {
        return taxonomies.find((m) => m.id === taxonomyElement.taxonomy_group.id);
    })
        .otherwise(() => undefined);
}
//# sourceMappingURL=element.utils.js.map