@stackbit/sdk/dist/utils/model-utils.js

Stackbit SDK

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getModelFieldForModelKeyPath = exports.resolveLabelFieldForModel = exports.assignLabelFieldIfNeeded = exports.mapListItemsPropsOrSelfSpecificProps = exports.getListItemsOrSelf = exports.normalizeListFieldInPlace = exports.normalizeListField = exports.getListFieldItems = exports.isCustomModelListItems = exports.isReferenceListItems = exports.isModelListItems = exports.isObjectListItems = exports.isListField = exports.isListOfCustomModelsField = exports.isListOfReferencesField = exports.isListOfModelsField = exports.isListOfObjectsField = exports.isEnumField = exports.isCustomModelField = exports.isCrossReferenceField = exports.isReferenceField = exports.isModelField = exports.isObjectField = exports.isSingleInstanceModel = exports.isObjectModel = exports.isPageModel = exports.isListDataModel = exports.isDataModel = exports.isConfigModel = exports.getModelByName = void 0;
const lodash_1 = __importDefault(require("lodash"));
const config_consts_1 = require("../config/config-consts");
function getModelByName(models, modelName) {
    return models.find((model) => model.name === modelName);
}
exports.getModelByName = getModelByName;
function isConfigModel(model) {
    return model.type === 'config';
}
exports.isConfigModel = isConfigModel;
function isDataModel(model) {
    return model.type === 'data';
}
exports.isDataModel = isDataModel;
function isListDataModel(model) {
    return isDataModel(model) && Boolean(model.isList);
}
exports.isListDataModel = isListDataModel;
function isPageModel(model) {
    return model.type === 'page';
}
exports.isPageModel = isPageModel;
function isObjectModel(model) {
    return model.type === 'object';
}
exports.isObjectModel = isObjectModel;
function isSingleInstanceModel(model) {
    if (model.type === 'config') {
        return true;
    }
    else if (model.type === 'data') {
        return lodash_1.default.has(model, 'file') || lodash_1.default.get(model, 'singleInstance', false);
    }
    else if (model.type === 'page') {
        return lodash_1.default.has(model, 'file') || lodash_1.default.get(model, 'singleInstance', false);
    }
    return false;
}
exports.isSingleInstanceModel = isSingleInstanceModel;
function isObjectField(field) {
    return field.type === 'object';
}
exports.isObjectField = isObjectField;
function isModelField(field) {
    return field.type === 'model';
}
exports.isModelField = isModelField;
function isReferenceField(field) {
    return field.type === 'reference';
}
exports.isReferenceField = isReferenceField;
function isCrossReferenceField(field) {
    return field.type === 'cross-reference';
}
exports.isCrossReferenceField = isCrossReferenceField;
function isCustomModelField(field, modelsByName) {
    // custom model field types are deprecated
    return !config_consts_1.FIELD_TYPES.includes(field.type) && lodash_1.default.has(modelsByName, field.type);
}
exports.isCustomModelField = isCustomModelField;
function isEnumField(field) {
    return field.type === 'enum';
}
exports.isEnumField = isEnumField;
function isListOfObjectsField(field) {
    return isListField(field) && isObjectListItems(getListFieldItems(field));
}
exports.isListOfObjectsField = isListOfObjectsField;
function isListOfModelsField(field) {
    return isListField(field) && isModelListItems(getListFieldItems(field));
}
exports.isListOfModelsField = isListOfModelsField;
function isListOfReferencesField(field) {
    return isListField(field) && isReferenceListItems(getListFieldItems(field));
}
exports.isListOfReferencesField = isListOfReferencesField;
function isListOfCustomModelsField(field, modelsByName) {
    // custom model field types are deprecated
    return isListField(field) && isCustomModelListItems(getListFieldItems(field), modelsByName);
}
exports.isListOfCustomModelsField = isListOfCustomModelsField;
function isListField(field) {
    // 'array' is deprecated field type
    return ['list', 'array'].includes(field.type);
}
exports.isListField = isListField;
function isObjectListItems(items) {
    return items.type === 'object';
}
exports.isObjectListItems = isObjectListItems;
function isModelListItems(items) {
    return items.type === 'model';
}
exports.isModelListItems = isModelListItems;
function isReferenceListItems(items) {
    return items.type === 'reference';
}
exports.isReferenceListItems = isReferenceListItems;
function isCustomModelListItems(items, modelsByName) {
    // custom model field types are deprecated
    return !config_consts_1.FIELD_TYPES.includes(items.type) && (!modelsByName || lodash_1.default.has(modelsByName, items.type));
}
exports.isCustomModelListItems = isCustomModelListItems;
/**
 * Gets a list field and returns its items field. If list field does not define
 * items field, the default field is string:
 *
 * @example
 * listItemField = getListFieldItems({
 *   type: 'list',
 *   name: '...',
 *   items: { type: 'object', fields: [] }
 * }
 * listItemField => {
 *   type: 'object',
 *   name: '...',
 *   fields: []
 * }
 *
 * // list field without `items`
 * listItemField = getListFieldItems({ type: 'list', name: '...' }
 * listItemField => { type: 'string' }
 *
 * @param {Object} field
 * @return {Object}
 */
function getListFieldItems(field) {
    // items.type defaults to string
    return Object.assign({ type: 'string' }, field.items);
}
exports.getListFieldItems = getListFieldItems;
function normalizeListField(field) {
    // in older versions, the list 'items' were optional and when weren't
    // specified a default list of strings was used.
    if (lodash_1.default.get(field, 'items.type')) {
        return field;
    }
    return {
        ...field,
        items: {
            ...(field.items ?? {}),
            type: 'string'
        }
    };
}
exports.normalizeListField = normalizeListField;
function normalizeListFieldInPlace(field) {
    // 'items.type' of list field default to 'string', set it explicitly
    if (!lodash_1.default.has(field, 'items.type')) {
        lodash_1.default.set(field, 'items.type', 'string');
    }
    return field;
}
exports.normalizeListFieldInPlace = normalizeListFieldInPlace;
function getListItemsOrSelf(field) {
    if (isListField(field)) {
        return normalizeListField(field).items;
    }
    return field;
}
exports.getListItemsOrSelf = getListItemsOrSelf;
function mapListItemsPropsOrSelfSpecificProps(field, func) {
    if (isListField(field)) {
        const listItems = normalizeListField(field).items;
        const mappedListItems = func(listItems);
        return {
            ...field,
            items: mappedListItems
        };
    }
    return func(field);
}
exports.mapListItemsPropsOrSelfSpecificProps = mapListItemsPropsOrSelfSpecificProps;
function assignLabelFieldIfNeeded(modelOrField) {
    if (modelOrField.labelField) {
        return;
    }
    const labelField = resolveLabelFieldForModel(modelOrField);
    if (labelField) {
        modelOrField.labelField = labelField;
    }
}
exports.assignLabelFieldIfNeeded = assignLabelFieldIfNeeded;
function resolveLabelFieldForModel(modelOrField) {
    const fields = lodash_1.default.get(modelOrField, 'fields');
    let labelField = lodash_1.default.get(modelOrField, 'labelField', null);
    if (labelField) {
        return labelField;
    }
    // see if there is a field named 'title'
    let titleField = lodash_1.default.find(fields, (field) => field.name === 'title' && ['string', 'text'].includes(field.type));
    if (!titleField) {
        // see if there is a field named 'label'
        titleField = lodash_1.default.find(fields, (field) => field.name === 'label' && ['string', 'text'].includes(field.type));
    }
    if (!titleField) {
        // get the first 'string' field
        titleField = lodash_1.default.find(fields, { type: 'string' });
    }
    if (titleField) {
        labelField = lodash_1.default.get(titleField, 'name');
    }
    return labelField || null;
}
exports.resolveLabelFieldForModel = resolveLabelFieldForModel;
function getModelFieldForModelKeyPath(model, modelKeyPath) {
    function _getField(field, modelKeyPath) {
        if (modelKeyPath.length === 0) {
            return field;
        }
        else if (isObjectField(field)) {
            return _getObjectFields(field, modelKeyPath);
        }
        else if (isListField(field)) {
            return _getListItems(field, modelKeyPath);
        }
        else {
            return null;
        }
    }
    function _getObjectFields(field, modelKeyPath) {
        if (modelKeyPath.length === 0) {
            return field;
        }
        const key = modelKeyPath.shift();
        if (key !== 'fields' || !field.fields) {
            return null;
        }
        if (modelKeyPath.length === 0) {
            return null;
        }
        const fieldName = modelKeyPath.shift();
        const childField = lodash_1.default.find(field.fields, (field) => field.name === fieldName);
        if (!childField) {
            return null;
        }
        return _getField(childField, modelKeyPath);
    }
    function _getListItems(field, modelKeyPath) {
        if (modelKeyPath.length === 0) {
            return field;
        }
        const key = modelKeyPath.shift();
        if (key !== 'items' || !field.items) {
            return null;
        }
        if (modelKeyPath.length === 0) {
            return field.items;
        }
        if (!isObjectListItems(field.items)) {
            return null;
        }
        return _getObjectFields(field.items, modelKeyPath);
    }
    modelKeyPath = modelKeyPath.slice();
    if (!model) {
        return null;
    }
    else if (isListDataModel(model)) {
        return _getListItems(model, modelKeyPath);
    }
    else {
        return _getObjectFields(model, modelKeyPath);
    }
}
exports.getModelFieldForModelKeyPath = getModelFieldForModelKeyPath;
//# sourceMappingURL=model-utils.js.map