@progress/sitefinity-nextjs-sdk/widgets/form-widgets/dynamic-list/dynamic-list.view-props.js

Provides OOB widgets developed using the Next.js framework, which includes an abstraction layer for Sitefinity communication. Additionally, it offers an expanded API, typings, and tools for further development and integration.

import { RestClient } from '../../../rest-sdk/rest-client';
import { RestClientForContext } from '../../../services/rest-client-for-context';
import { SelectionMode, TaxonSelectionMode } from './selection-modes';
import { ServiceMetadata } from '../../../rest-sdk/service-metadata';
export async function getChoiceItems(entity, requestContext, traceContext) {
    let items = [];
    let defaultFieldName = 'Title';
    if (entity.ListType === SelectionMode.Classification) {
        items = await getClassifications(entity, traceContext);
    }
    else if (entity.ListType === SelectionMode.Content) {
        const [itemsFromContent, defaultFieldNameFromContent] = await getContent(entity, requestContext, traceContext);
        items = itemsFromContent;
        defaultFieldName = defaultFieldNameFromContent ?? defaultFieldName;
    }
    return transformItemsToChoices(items, defaultFieldName, entity);
}
async function getContent(entity, requestContext, traceContext) {
    if (entity.SelectedContent?.Content &&
        entity.SelectedContent.Content.length > 0 &&
        entity.SelectedContent.Content[0].Type != null) {
        const itemType = entity.SelectedContent.Content[0].Type;
        const defaultFieldName = await ServiceMetadata.getDefaultFieldName(itemType);
        const getAllArgs = {
            orderBy: [],
            type: itemType,
            culture: requestContext.culture,
            traceContext
        };
        const orderBy = getOrderByExpressionForContent(entity);
        if (orderBy !== null) {
            getAllArgs.orderBy.push(orderBy);
        }
        const itemsResponse = await RestClientForContext.getItems(entity.SelectedContent, getAllArgs);
        return [itemsResponse.Items, defaultFieldName];
    }
    return [[], null];
}
function getOrderByExpressionForContent(entity) {
    if (entity.OrderByContent === 'Manually') {
        return null;
    }
    const sortExpression = entity.OrderByContent === 'Custom' ? entity.SortExpression : entity.OrderByContent;
    if (!sortExpression) {
        return null;
    }
    const sortExpressionParts = sortExpression.split(' ');
    if (sortExpressionParts.length !== 2) {
        return null;
    }
    const sortOrder = sortExpressionParts[1].toUpperCase() === 'ASC' ? 'asc' : 'desc';
    const orderBy = { Name: sortExpressionParts[0], Type: sortOrder };
    return orderBy;
}
async function getClassifications(entity, traceContext) {
    const settings = entity.ClassificationSettings;
    if (settings && settings.selectedTaxonomyId) {
        let orderBy = entity.OrderBy || 'Title ASC';
        if (orderBy === 'Custom') {
            orderBy = entity.SortExpression || '';
        }
        else if (orderBy === 'Manually') {
            orderBy = 'Ordinal';
        }
        return RestClient.getTaxons({
            contentType: settings.byContentType,
            orderBy: orderBy,
            selectionMode: settings.selectionMode,
            taxonomyId: settings.selectedTaxonomyId,
            showEmpty: true,
            taxaIds: settings.selectedTaxaIds,
            traceContext
        });
    }
    return Promise.resolve([]);
}
function transformItemsToChoices(items, defaultFieldName, entity) {
    if (!items) {
        return [];
    }
    let returnVal = [];
    const taxa = items;
    if (entity.ListType === SelectionMode.Classification && entity.ClassificationSettings?.selectionMode === TaxonSelectionMode.All && taxa != null) {
        getAllTaxa(taxa, defaultFieldName, entity, returnVal);
    }
    else {
        returnVal = items.map(x => {
            return getOption(x, defaultFieldName, entity);
        });
    }
    return returnVal;
}
function getAllTaxa(taxa, defaultFieldName, entity, taxaChoices) {
    taxa.forEach(item => {
        const option = getOption(item, defaultFieldName, entity);
        taxaChoices.push(option);
        getAllTaxa(item.SubTaxa, defaultFieldName, entity, taxaChoices);
    });
}
function getOption(item, defaultFieldName, entity) {
    const option = {
        Name: item[defaultFieldName],
        Value: entity.ValueFieldName && item[entity.ValueFieldName] ? item[entity.ValueFieldName] : item[defaultFieldName],
        Selected: false
    };
    return option;
}