strapi-plugin-navigation 2.0.13 → 2.1.0

package/server/services/client.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const slugify_1 = __importDefault(require("slugify"));
+const uuid_1 = require("uuid");
+const types_1 = require("../../types");
+const utils_1 = require("../utils");
+const utils_2 = require("@strapi/utils");
+const i18n_1 = require("../i18n");
+const NavigationError_1 = require("../../utils/NavigationError");
+const clientService = ({ strapi }) => ({
+    async render({ idOrSlug, type = utils_1.RENDER_TYPES.FLAT, menuOnly = false, rootPath = null, wrapRelated = false, locale, }) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        const findById = !isNaN((0, lodash_1.toNumber)(idOrSlug)) || (0, uuid_1.validate)(idOrSlug);
+        const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+        const itemCriteria = menuOnly ? { menuAttached: true } : {};
+        return await clientService.renderType({
+            type, criteria, itemCriteria, filter: null, rootPath, wrapRelated, locale,
+        });
+    },
+    async renderChildren({ idOrSlug, childUIKey, type = utils_1.RENDER_TYPES.FLAT, menuOnly = false, wrapRelated = false, locale, }) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        const findById = !isNaN((0, lodash_1.toNumber)(idOrSlug)) || (0, uuid_1.validate)(idOrSlug);
+        const criteria = findById ? { id: idOrSlug } : { slug: idOrSlug };
+        const filter = type === utils_1.RENDER_TYPES.FLAT ? null : childUIKey;
+        const itemCriteria = {
+            ...(menuOnly && { menuAttached: true }),
+            ...(type === utils_1.RENDER_TYPES.FLAT ? { uiRouterKey: childUIKey } : {}),
+        };
+        return clientService.renderType({ type, criteria, itemCriteria, filter, rootPath: null, wrapRelated, locale });
+    },
+    renderRFR(items, parent = null, parentNavItem = null, contentTypes = []) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        let pages = {};
+        let nav = {};
+        let navItems = [];
+        items.forEach(item => {
+            const { items: itemChilds, ...itemProps } = item;
+            const itemNav = clientService.renderRFRNav(itemProps);
+            const itemPage = clientService.renderRFRPage(itemProps, parent);
+            if (item.type === "INTERNAL") {
+                pages = {
+                    ...pages,
+                    [itemPage.id]: {
+                        ...itemPage,
+                    },
+                };
+            }
+            if (item.menuAttached) {
+                navItems.push(itemNav);
+            }
+            if (!parent) {
+                nav = {
+                    ...nav,
+                    root: navItems,
+                };
+            }
+            else {
+                const navLevel = navItems
+                    .filter(navItem => navItem.type === "INTERNAL");
+                if (!(0, lodash_1.isEmpty)(navLevel))
+                    nav = {
+                        ...nav,
+                        [parent]: navLevel.concat(parentNavItem ? parentNavItem : []),
+                    };
+            }
+            if (!(0, lodash_1.isEmpty)(itemChilds)) {
+                const { nav: nestedNavs } = clientService.renderRFR(itemChilds, itemPage.id, itemNav, contentTypes);
+                const { pages: nestedPages } = clientService.renderRFR((itemChilds).filter(child => child.type === "INTERNAL"), itemPage.id, itemNav, contentTypes);
+                pages = {
+                    ...pages,
+                    ...nestedPages,
+                };
+                nav = {
+                    ...nav,
+                    ...nestedNavs,
+                };
+            }
+        });
+        return {
+            pages,
+            nav,
+        };
+    },
+    renderRFRNav(item) {
+        const { uiRouterKey, title, path, type, audience } = item;
+        const itemCommon = {
+            label: title,
+            type: type,
+            audience,
+        };
+        if (type === "EXTERNAL") {
+            (0, types_1.assertNotEmpty)(path, new NavigationError_1.NavigationError("External navigation item's path is undefined", item));
+            return {
+                ...itemCommon,
+                url: path
+            };
+        }
+        if (type === "INTERNAL") {
+            return {
+                ...itemCommon,
+                page: uiRouterKey,
+            };
+        }
+        throw new NavigationError_1.NavigationError("Unknown item type", item);
+    },
+    renderRFRPage(item, parent) {
+        const { uiRouterKey, title, path, slug, related, type, audience, menuAttached } = item;
+        const { __contentType, id, __templateName } = related || {};
+        const contentType = __contentType || '';
+        return {
+            id: uiRouterKey,
+            title,
+            templateName: __templateName,
+            related: type === "INTERNAL" ? {
+                contentType,
+                id,
+            } : undefined,
+            path,
+            slug,
+            parent,
+            audience,
+            menuAttached,
+        };
+    },
+    renderTree(items = [], id = null, field = 'parent', path = '', itemParser = (i) => i) {
+        return items
+            .filter((item) => {
+            if (item[field] === null && id === null) {
+                return true;
+            }
+            let data = item[field];
+            if (data && typeof id === 'string') {
+                data = data.toString();
+            }
+            if (!!data && typeof data === 'object' && 'id' in data) {
+                return data.id === id;
+            }
+            return (data && data === id);
+        })
+            .filter(utils_1.filterOutUnpublished)
+            .map(item => itemParser({
+            ...item,
+        }, path, field))
+            .sort((x, y) => {
+            if (x.order !== undefined && y.order !== undefined)
+                return x.order - y.order;
+            else
+                return 0;
+        });
+    },
+    async renderType({ type = utils_1.RENDER_TYPES.FLAT, criteria = {}, itemCriteria = {}, filter = null, rootPath = null, wrapRelated = false, locale, }) {
+        const clientService = (0, utils_1.getPluginService)('client');
+        const adminService = (0, utils_1.getPluginService)('admin');
+        const commonService = (0, utils_1.getPluginService)('common');
+        const entityWhereClause = {
+            ...criteria,
+            visible: true,
+        };
+        const { masterModel, itemModel } = (0, utils_1.extractMeta)(strapi.plugins);
+        const entity = await (0, i18n_1.i18nAwareEntityReadHandler)({
+            entity: await strapi
+                .query(masterModel.uid)
+                .findOne({
+                where: entityWhereClause,
+            }),
+            entityUid: masterModel.uid,
+            strapi,
+            whereClause: entityWhereClause,
+            localeCode: locale,
+        });
+        if (entity && entity.id) {
+            const entities = await strapi.query(itemModel.uid).findMany({
+                where: {
+                    master: entity.id,
+                    ...itemCriteria,
+                },
+                limit: Number.MAX_SAFE_INTEGER,
+                orderBy: [{ order: 'asc', }],
+                populate: ['related', 'audience', 'parent'],
+            });
+            if (!entities) {
+                return [];
+            }
+            const items = await commonService.getRelatedItems(entities);
+            const { contentTypes, contentTypesNameFields } = await adminService.config(false);
+            const wrapContentType = (itemContentType) => wrapRelated && itemContentType ? {
+                id: itemContentType.id,
+                attributes: { ...itemContentType }
+            } : itemContentType;
+            switch (type) {
+                case utils_1.RENDER_TYPES.TREE:
+                case utils_1.RENDER_TYPES.RFR:
+                    const getTemplateName = await (0, utils_1.templateNameFactory)(items, strapi, contentTypes);
+                    const itemParser = (item, path = '', field) => {
+                        const isExternal = item.type === "EXTERNAL";
+                        const parentPath = isExternal ? undefined : `${path === '/' ? '' : path}/${(0, lodash_1.first)(item.path) === '/'
+                            ? item.path.substring(1)
+                            : item.path}`;
+                        const slug = (0, lodash_1.isString)(parentPath) ? (0, slugify_1.default)(((0, lodash_1.first)(parentPath) === '/' ? parentPath.substring(1) : parentPath).replace(/\//g, '-')) : undefined;
+                        const lastRelated = (0, lodash_1.isArray)(item.related) ? (0, lodash_1.last)(item.related) : item.related;
+                        const relatedContentType = wrapContentType(lastRelated);
+                        return {
+                            id: item.id,
+                            title: (0, utils_1.composeItemTitle)(item, contentTypesNameFields, contentTypes),
+                            menuAttached: item.menuAttached,
+                            order: item.order,
+                            path: isExternal ? item.externalPath : parentPath,
+                            type: item.type,
+                            uiRouterKey: item.uiRouterKey,
+                            slug: !slug && item.uiRouterKey ? (0, slugify_1.default)(item.uiRouterKey) : slug,
+                            external: isExternal,
+                            related: isExternal || !lastRelated ? undefined : {
+                                ...relatedContentType,
+                                __templateName: getTemplateName((lastRelated.relatedType || lastRelated.__contentType), lastRelated.id),
+                            },
+                            audience: !(0, lodash_1.isEmpty)(item.audience) ? item.audience.map(aItem => (aItem).key) : undefined,
+                            items: isExternal ? undefined : clientService.renderTree(items, item.id, field, parentPath, itemParser),
+                        };
+                    };
+                    const { items: itemsFilteredByPath, root: rootElement, } = (0, utils_1.filterByPath)(items, rootPath);
+                    const treeStructure = clientService.renderTree((0, lodash_1.isNil)(rootPath) ? items : itemsFilteredByPath, (0, lodash_1.get)(rootElement, 'parent.id'), 'parent', (0, lodash_1.get)(rootElement, 'parent.path'), itemParser);
+                    const filteredStructure = filter
+                        ? treeStructure.filter((item) => item.uiRouterKey === filter)
+                        : treeStructure;
+                    if (type === utils_1.RENDER_TYPES.RFR) {
+                        return clientService.renderRFR(filteredStructure, null, null, contentTypes);
+                    }
+                    return filteredStructure;
+                default:
+                    const publishedItems = items.filter(utils_1.filterOutUnpublished);
+                    const result = (0, lodash_1.isNil)(rootPath) ? items : (0, utils_1.filterByPath)(publishedItems, rootPath).items;
+                    return result.map((item) => ({
+                        ...item,
+                        audience: item.audience?.map(_ => (_).key),
+                        title: (0, utils_1.composeItemTitle)(item, contentTypesNameFields, contentTypes) || '',
+                        related: wrapContentType(item.related),
+                        items: null,
+                    }));
+            }
+        }
+        throw new utils_2.errors.NotFoundError();
+    },
+});
+exports.default = clientService;
+//# sourceMappingURL=client.js.map

package/server/services/common.d.ts

@@ -0,0 +1,5 @@
+import { StrapiContext } from "strapi-typed";
+import { ICommonService } from "../../types";
+declare const commonService: (context: StrapiContext) => ICommonService;
+export default commonService;
+//# sourceMappingURL=common.d.ts.map

package/server/services/common.js

@@ -0,0 +1,313 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const pluralize_1 = __importDefault(require("pluralize"));
+const utils_1 = require("@strapi/utils");
+const config_1 = require("../config");
+const i18n_1 = require("../i18n");
+const utils_2 = require("../utils");
+const commonService = ({ strapi }) => ({
+    analyzeBranch(items = [], masterEntity = null, parentItem = null, prevOperations = {}) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { toCreate, toRemove, toUpdate } = items
+            .reduce((acc, _) => {
+            const branchName = commonService.getBranchName(_);
+            if (branchName) {
+                return { ...acc, [branchName]: [...acc[branchName], _] };
+            }
+            return acc;
+        }, { toRemove: [], toCreate: [], toUpdate: [] });
+        const operations = {
+            create: prevOperations.create || !!toCreate.length,
+            update: prevOperations.update || !!toUpdate.length,
+            remove: prevOperations.remove || !!toRemove.length,
+        };
+        return (0, utils_2.checkDuplicatePath)(parentItem || masterEntity, toCreate.concat(toUpdate))
+            .then(() => Promise.all([
+            commonService.createBranch(toCreate, masterEntity, parentItem, operations),
+            commonService.removeBranch(toRemove, operations),
+            commonService.updateBranch(toUpdate, masterEntity, parentItem, operations),
+        ]));
+    },
+    async configContentTypes(viaSettingsPage = false) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const eligibleContentTypes = await Promise.all(config.contentTypes
+            .filter(contentType => !!strapi.contentTypes[contentType] && (0, utils_2.isContentTypeEligible)(contentType))
+            .map(async (key) => {
+            const item = strapi.contentTypes[key];
+            const { kind, options, uid } = item;
+            const { draftAndPublish } = options;
+            const isSingleType = kind === utils_2.KIND_TYPES.SINGLE;
+            const isSingleTypeWithPublishFlow = isSingleType && draftAndPublish;
+            const returnType = (available) => ({
+                key,
+                available,
+            });
+            if (isSingleType) {
+                if (isSingleTypeWithPublishFlow) {
+                    const itemsCountOrBypass = isSingleTypeWithPublishFlow ?
+                        await strapi.query(uid).count({
+                            where: {
+                                published_at: { $notNull: true },
+                            },
+                        }) :
+                        true;
+                    return returnType(itemsCountOrBypass !== 0);
+                }
+                const isAvailable = await strapi.query(uid).count({});
+                return isAvailable !== 0 ?
+                    returnType(true) :
+                    (viaSettingsPage ? returnType(false) : undefined);
+            }
+            return returnType(true);
+        }));
+        return eligibleContentTypes
+            .filter(key => key)
+            .map((value) => {
+            if (value === undefined)
+                return;
+            const { key, available } = value;
+            const item = strapi.contentTypes[key];
+            const relatedField = (item.associations || []).find((_) => _.model === 'navigationitem');
+            const { uid, options, info, collectionName, modelName, apiName, plugin, kind, pluginOptions } = item;
+            const { visible = true } = pluginOptions['content-manager'] || {};
+            const { name, description } = info;
+            const { hidden, templateName, draftAndPublish } = options;
+            const findRouteConfig = (0, lodash_1.find)((0, lodash_1.get)(strapi.api, `[${modelName}].config.routes`, []), route => route.handler.includes('.find'));
+            const findRoutePath = findRouteConfig && findRouteConfig.path.split('/')[1];
+            const apiPath = findRoutePath && (findRoutePath !== apiName) ? findRoutePath : apiName || modelName;
+            const isSingle = kind === utils_2.KIND_TYPES.SINGLE;
+            const endpoint = isSingle ? apiPath : (0, pluralize_1.default)(apiPath);
+            const relationName = (0, utils_2.singularize)(modelName);
+            const relationNameParts = typeof uid === 'string' ? (0, lodash_1.last)((uid).split('.')).split('-') : [];
+            const contentTypeName = relationNameParts.length > 1 ? relationNameParts.reduce((prev, curr) => `${prev}${(0, lodash_1.upperFirst)(curr)}`, '') : (0, lodash_1.upperFirst)(modelName);
+            const labelSingular = name ||
+                ((0, lodash_1.upperFirst)(relationNameParts.length > 1 ? relationNameParts.join(' ') : relationName));
+            return {
+                uid,
+                name: relationName,
+                draftAndPublish,
+                isSingle,
+                description,
+                collectionName,
+                contentTypeName,
+                label: isSingle ? labelSingular : (0, pluralize_1.default)(name || labelSingular),
+                relatedField: relatedField ? relatedField.alias : undefined,
+                labelSingular: (0, utils_2.singularize)(labelSingular),
+                endpoint,
+                plugin,
+                available: available && !hidden,
+                visible,
+                templateName,
+            };
+        })
+            .filter((item) => viaSettingsPage || (item && item.available));
+    },
+    async createBranch(items, masterEntity, parentItem, operations) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { itemModel } = (0, utils_2.extractMeta)(strapi.plugins);
+        return await Promise.all(items.map(async (item) => {
+            operations.create = true;
+            const { parent, master, related, ...params } = item;
+            const relatedItems = await this.getIdsRelated(related, master);
+            const data = {
+                ...params,
+                related: relatedItems,
+                master: masterEntity,
+                parent: parentItem ? { ...parentItem, _id: parentItem.id } : null,
+            };
+            const navigationItem = await strapi
+                .query(itemModel.uid)
+                .create({ data, populate: ['related'] });
+            return !(0, lodash_1.isEmpty)(item.items)
+                ? commonService.createBranch(item.items, masterEntity, navigationItem, operations)
+                : operations;
+        }));
+    },
+    getBranchName(item) {
+        const hasId = !(0, lodash_1.isNil)(item.id);
+        const toRemove = item.removed;
+        if (hasId && !toRemove) {
+            return 'toUpdate';
+        }
+        if (hasId && toRemove) {
+            return 'toRemove';
+        }
+        if (!hasId && !toRemove) {
+            return 'toCreate';
+        }
+    },
+    async getContentTypeItems(uid, query) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const where = await (0, i18n_1.addI18nWhereClause)({
+            strapi,
+            previousWhere: {},
+            query,
+            modelUid: uid,
+        });
+        try {
+            const contentTypeItems = await strapi.query(uid).findMany({
+                populate: config.contentTypesPopulate[uid] || [],
+                where,
+            });
+            return contentTypeItems;
+        }
+        catch (err) {
+            return [];
+        }
+    },
+    async getIdsRelated(relatedItems, master) {
+        if (relatedItems) {
+            return (await Promise.all(relatedItems.map(async (relatedItem) => {
+                try {
+                    const model = strapi.query("plugin::navigation.navigations-items-related");
+                    const entity = await model.findOne({
+                        where: {
+                            related_id: relatedItem.refId,
+                            related_type: relatedItem.ref,
+                            field: relatedItem.field,
+                            master,
+                        },
+                    });
+                    if (!entity) {
+                        const newEntity = {
+                            master,
+                            order: 1,
+                            field: relatedItem.field,
+                            related_id: relatedItem.refId,
+                            related_type: relatedItem.ref,
+                        };
+                        return model.create({ data: newEntity }).then(({ id }) => id);
+                    }
+                    return entity.id;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }))).reduce((acc, id) => (id ? acc.concat([id]) : acc), []);
+        }
+    },
+    async getPluginStore() {
+        return await strapi.store({ type: 'plugin', name: 'navigation' });
+    },
+    async getRelatedItems(entityItems) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const pluginStore = await commonService.getPluginStore();
+        const config = await pluginStore.get({ key: 'config' });
+        const relatedTypes = new Set(entityItems.flatMap((item) => (0, lodash_1.get)(item.related, 'related_type', '')));
+        const groupedItems = Array.from(relatedTypes).filter((relatedType) => relatedType).reduce((acc, relatedType) => Object.assign(acc, {
+            [relatedType]: [
+                ...(acc[relatedType] || []),
+                ...entityItems
+                    .filter((item => (0, lodash_1.get)(item.related, 'related_type') === relatedType))
+                    .flatMap((item) => Object.assign(item.related, { navigationItemId: item.id })),
+            ],
+        }), {});
+        const data = new Map((await Promise.all(Object.entries(groupedItems)
+            .map(async ([model, related]) => {
+            const relationData = await strapi
+                .query(model)
+                .findMany({
+                where: {
+                    id: { $in: (0, lodash_1.map)(related, 'related_id') },
+                },
+                populate: config.contentTypesPopulate[model] || []
+            });
+            return relationData
+                .flatMap(_ => Object.assign(_, {
+                __contentType: model,
+                navigationItemId: related.find(({ related_id }) => related_id === _.id.toString())?.navigationItemId,
+            }));
+        })))
+            .flat(1)
+            .map(_ => [_.navigationItemId, _]));
+        return entityItems
+            .map(({ related, ...item }) => {
+            const relatedData = data.get(item.id);
+            if (relatedData) {
+                return Object.assign(item, { related: relatedData });
+            }
+            return { ...item, related: null };
+        });
+    },
+    removeBranch(items = [], operations = {}) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { itemModel } = (0, utils_2.extractMeta)(strapi.plugins);
+        return Promise.all(items
+            .filter(item => item.id)
+            .map(async (item) => {
+            operations.remove = true;
+            const { id, related, master } = item;
+            await Promise.all([
+                strapi
+                    .query(itemModel.uid)
+                    .delete({ where: { id } }),
+                this.removeRelated(related, master),
+            ]);
+            return !(0, lodash_1.isEmpty)(item.items)
+                ? commonService.removeBranch(item.items, operations)
+                : operations;
+        }));
+    },
+    removeRelated(relatedItems, master) {
+        return Promise.all((relatedItems || []).map(relatedItem => {
+            const model = strapi.query('plugin::navigation.navigations-items-related');
+            const entityToRemove = {
+                master,
+                field: relatedItem.field,
+                related_id: relatedItem.refId,
+                related_type: relatedItem.ref,
+            };
+            return model.delete({ where: entityToRemove });
+        }));
+    },
+    setDefaultConfig() {
+        return (0, config_1.configSetupStrategy)({ strapi });
+    },
+    async updateBranch(toUpdate, masterEntity, parentItem, operations) {
+        const commonService = (0, utils_2.getPluginService)('common');
+        const { itemModel } = (0, utils_2.extractMeta)(strapi.plugins);
+        const databaseModel = strapi.query(itemModel.uid);
+        return Promise.all(toUpdate.map(async (item) => {
+            operations.update = true;
+            const { id, updated, parent, master, related, items, ...params } = item;
+            let currentItem;
+            if (updated) {
+                const relatedItems = await this.getIdsRelated(related, master);
+                currentItem = await databaseModel
+                    .update({
+                    where: { id },
+                    data: {
+                        ...params,
+                        related: relatedItems,
+                        master: masterEntity,
+                        parent: parentItem ? { ...parentItem, _id: parentItem.id } : null,
+                    },
+                });
+            }
+            else {
+                currentItem = item;
+            }
+            return !(0, lodash_1.isEmpty)(items)
+                ? commonService.analyzeBranch(items, masterEntity, currentItem, operations)
+                : operations;
+        }));
+    },
+    async emitEvent(uid, event, entity) {
+        const model = strapi.getModel(uid);
+        const sanitizedEntity = await utils_1.sanitize.sanitizers.defaultSanitizeOutput(model, entity);
+        strapi.webhookRunner.eventHub.emit(event, {
+            model: model.modelName,
+            entry: sanitizedEntity,
+        });
+    }
+});
+exports.default = commonService;
+//# sourceMappingURL=common.js.map

package/server/services/index.d.ts

@@ -0,0 +1,7 @@
+declare const navigationService: {
+    common: (context: import("strapi-typed").StrapiContext) => import("../../types").ICommonService;
+    admin: (context: import("strapi-typed").StrapiContext) => import("../../types").IAdminService;
+    client: (context: import("strapi-typed").StrapiContext) => import("../../types").IClientService;
+};
+export default navigationService;
+//# sourceMappingURL=index.d.ts.map

package/server/services/index.js

@@ -1,7 +1,15 @@
-"use strict"
-
-const navigation = require("./navigation");
-
-module.exports = {
-  navigation
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = __importDefault(require("./common"));
+const admin_1 = __importDefault(require("./admin"));
+const client_1 = __importDefault(require("./client"));
+const navigationService = {
+    common: common_1.default,
+    admin: admin_1.default,
+    client: client_1.default,
+};
+exports.default = navigationService;
+//# sourceMappingURL=index.js.map

package/server/utils/constant.d.ts

@@ -0,0 +1,27 @@
+export declare const TEMPLATE_DEFAULT: "Generic";
+export declare const MODEL_TYPES: {
+    readonly CONTENT_TYPE: "contentType";
+};
+export declare const KIND_TYPES: {
+    readonly SINGLE: "singleType";
+    readonly COLLECTION: "collectionType";
+};
+export declare const ALLOWED_CONTENT_TYPES: readonly ["api::", "plugin::"];
+export declare const RESTRICTED_CONTENT_TYPES: readonly ["plugin::users-permissions", "plugin::i18n.locale", "plugin::navigation"];
+export declare const EXCLUDED_CONTENT_TYPES: string[];
+export declare const CONTENT_TYPES_NAME_FIELDS_DEFAULTS: string[];
+export declare const ADDITIONAL_FIELDS: {
+    AUDIENCE: string;
+};
+export declare const DEFAULT_POPULATE: "localizations"[];
+export declare const DEFAULT_NAVIGATION_ITEM: {
+    readonly name: "Main navigation";
+    readonly slug: "main-navigation";
+    readonly visible: true;
+};
+export declare const RENDER_TYPES: Readonly<{
+    FLAT: "FLAT";
+    TREE: "TREE";
+    RFR: "RFR";
+}>;
+//# sourceMappingURL=constant.d.ts.map

package/server/utils/constant.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RENDER_TYPES = exports.DEFAULT_NAVIGATION_ITEM = exports.DEFAULT_POPULATE = exports.ADDITIONAL_FIELDS = exports.CONTENT_TYPES_NAME_FIELDS_DEFAULTS = exports.EXCLUDED_CONTENT_TYPES = exports.RESTRICTED_CONTENT_TYPES = exports.ALLOWED_CONTENT_TYPES = exports.KIND_TYPES = exports.MODEL_TYPES = exports.TEMPLATE_DEFAULT = void 0;
+const i18n_1 = require("../i18n");
+exports.TEMPLATE_DEFAULT = 'Generic';
+exports.MODEL_TYPES = { CONTENT_TYPE: 'contentType' };
+exports.KIND_TYPES = { SINGLE: 'singleType', COLLECTION: 'collectionType' };
+exports.ALLOWED_CONTENT_TYPES = ['api::', 'plugin::'];
+exports.RESTRICTED_CONTENT_TYPES = ['plugin::users-permissions', 'plugin::i18n.locale', 'plugin::navigation'];
+exports.EXCLUDED_CONTENT_TYPES = ['strapi::'];
+exports.CONTENT_TYPES_NAME_FIELDS_DEFAULTS = ['title', 'subject', 'name'];
+exports.ADDITIONAL_FIELDS = { AUDIENCE: 'audience' };
+exports.DEFAULT_POPULATE = [...i18n_1.I18N_DEFAULT_POPULATE];
+exports.DEFAULT_NAVIGATION_ITEM = {
+    name: "Main navigation",
+    slug: "main-navigation",
+    visible: true,
+};
+exports.RENDER_TYPES = {
+    FLAT: 'FLAT',
+    TREE: 'TREE',
+    RFR: 'RFR'
+};
+//# sourceMappingURL=constant.js.map