strapi-plugin-navigation 2.0.13 → 2.1.0

package/admin/src/pages/View/utils/form.d.ts

@@ -0,0 +1,2 @@
+export function checkFormValidity(data: any, schema: any): Promise<any>;
+//# sourceMappingURL=form.d.ts.map

package/admin/src/pages/View/utils/form.js

@@ -1,13 +1,16 @@
-import { getYupInnerErrors } from '@strapi/helper-plugin';
-
-export const checkFormValidity = async (data, schema) => {
-  let errors = null;
-
-  try {
-    await schema.validate(data, { abortEarly: false });
-  } catch (err) {
-    errors = getYupInnerErrors(err);
-  }
-
-  return errors;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFormValidity = void 0;
+const helper_plugin_1 = require("@strapi/helper-plugin");
+const checkFormValidity = async (data, schema) => {
+    let errors = null;
+    try {
+        await schema.validate(data, { abortEarly: false });
+    }
+    catch (err) {
+        errors = (0, helper_plugin_1.getYupInnerErrors)(err);
+    }
+    return errors;
 };
+exports.checkFormValidity = checkFormValidity;
+//# sourceMappingURL=form.js.map

package/admin/src/pages/View/utils/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/admin/src/pages/View/utils/index.js

@@ -1,3 +1,11 @@
-/* eslint-disable import/prefer-default-export */
-export { default as forms } from "./forms";
-export { default as parsers } from "./parsers";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsers = exports.forms = void 0;
+var forms_1 = require("./forms");
+Object.defineProperty(exports, "forms", { enumerable: true, get: function () { return __importDefault(forms_1).default; } });
+var parsers_1 = require("./parsers");
+Object.defineProperty(exports, "parsers", { enumerable: true, get: function () { return __importDefault(parsers_1).default; } });
+//# sourceMappingURL=index.js.map

package/admin/src/pages/View/utils/parsers.d.ts

@@ -0,0 +1,49 @@
+export function transformItemToRESTPayload(item: any, parent?: undefined, master?: undefined, config?: {}, parentAttachedToMenu?: boolean): {
+    id: any;
+    parent: undefined;
+    master: undefined;
+    title: any;
+    type: any;
+    updated: any;
+    removed: any;
+    order: any;
+    uiRouterKey: any;
+    collapsed: any;
+    menuAttached: any;
+    audience: any;
+    path: any;
+    externalPath: any;
+    related: {
+        refId: any;
+        ref: any;
+        field: any;
+    }[] | undefined;
+    items: any;
+};
+export function transformToRESTPayload(payload: any, config?: {}): {
+    id: any;
+    name: any;
+    visible: any;
+    items: any;
+};
+export function transformItemToViewPayload(payload: any, items: any[] | undefined, config: any): any;
+export function prepareItemToViewPayload({ items, viewParentId, config, structureIdPrefix }: {
+    items?: any[] | undefined;
+    viewParentId?: null | undefined;
+    config?: {} | undefined;
+    structureIdPrefix?: string | undefined;
+}): any;
+export function extractRelatedItemLabel(item?: {}, fields?: {}, config?: {}): any;
+export function usedContentTypes(items?: any[]): any;
+export function isRelationCorrect({ related, type }: {
+    related: any;
+    type: any;
+}): boolean;
+export function isRelationPublished({ relatedRef, relatedType, type, isCollection }: {
+    relatedRef: any;
+    relatedType?: {} | undefined;
+    type: any;
+    isCollection: any;
+}): any;
+export function validateNavigationStructure(items?: any[]): any;
+//# sourceMappingURL=parsers.d.ts.map

package/admin/src/pages/View/utils/parsers.js

@@ -1,307 +1,268 @@
-import { v4 as uuid, validate as isUuid } from 'uuid'
-import { find, get, isArray, isEmpty, isNil, isNumber, isObject, isString, last, omit, orderBy } from 'lodash';
-import { navigationItemType } from './enums';
-
-export const transformItemToRESTPayload = (
-  item,
-  parent = undefined,
-  master = undefined,
-  config = {},
-  parentAttachedToMenu = true,
-) => {
-  const {
-    id,
-    title,
-    type = navigationItemType.INTERNAL,
-    updated = false,
-    removed = false,
-    uiRouterKey,
-    menuAttached,
-    path,
-    externalPath,
-    related,
-    relatedType,
-    order,
-    audience = [],
-    items = [],
-    collapsed,
-    isSingle
-  } = item;
-  const isExternal = type === navigationItemType.EXTERNAL;
-  const isWrapper = type === navigationItemType.WRAPPER;
-  const { contentTypes = [] } = config;
-
-  const parsedRelated = Number(related);
-  const relatedId = isExternal || isWrapper || isNaN(parsedRelated) ? related?.value || related : parsedRelated;
-
-  const relatedContentType = relatedType ?
-    find(contentTypes,
-      ct => ct.uid === relatedType) :
-    undefined;
-  const itemAttachedToMenu = menuAttached && parentAttachedToMenu;
-  return {
-    id,
-    parent,
-    master,
-    title,
-    type,
-    updated,
-    removed,
-    order,
-    uiRouterKey,
-    collapsed,
-    menuAttached: itemAttachedToMenu,
-    audience: audience.map((audienceItem) =>
-      isObject(audienceItem) ? audienceItem.value : audienceItem,
-    ),
-    path: isExternal ? undefined : path,
-    externalPath: isExternal ? externalPath : undefined,
-    related: isExternal || isWrapper
-      ? undefined
-      : [
-        {
-          refId: isSingle && !relatedId ? 1 : relatedId,
-          ref: relatedContentType ? relatedContentType.uid : relatedType,
-          field: relatedContentType && relatedContentType.relatedField ? relatedContentType.relatedField : 'navigation',
-        },
-      ],
-    items: items.map((iItem) => transformItemToRESTPayload(iItem, id, master, config, itemAttachedToMenu)),
-  };
-};
-
-export const transformToRESTPayload = (payload, config = {}) => {
-  const { id, name, visible, items } = payload;
-  return {
-    id,
-    name,
-    visible,
-    items: items.map((item) => transformItemToRESTPayload(item, null, id, config)),
-  };
-};
-
-const linkRelations = (item, config) => {
-  const { contentTypeItems = [], contentTypes = [] } = config;
-  const { type, related, relatedType, relatedRef, isSingle } = item;
-  let relation = {
-    related: undefined,
-    relatedRef: undefined,
-    relatedType: undefined,
-  };
-
-  if (isSingle && relatedType) {
-    const relatedContentType = contentTypes.find(_ => relatedType === _.uid) || {};
-    const { singleRelatedItem = {} } = item;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNavigationStructure = exports.isRelationPublished = exports.isRelationCorrect = exports.usedContentTypes = exports.extractRelatedItemLabel = exports.prepareItemToViewPayload = exports.transformItemToViewPayload = exports.transformToRESTPayload = exports.transformItemToRESTPayload = void 0;
+const uuid_1 = require("uuid");
+const lodash_1 = require("lodash");
+const enums_1 = require("./enums");
+const transformItemToRESTPayload = (item, parent = undefined, master = undefined, config = {}, parentAttachedToMenu = true) => {
+    const { id, title, type = enums_1.navigationItemType.INTERNAL, updated = false, removed = false, uiRouterKey, menuAttached, path, externalPath, related, relatedType, order, audience = [], items = [], collapsed, isSingle } = item;
+    const isExternal = type === enums_1.navigationItemType.EXTERNAL;
+    const isWrapper = type === enums_1.navigationItemType.WRAPPER;
+    const { contentTypes = [] } = config;
+    const parsedRelated = Number(related);
+    const relatedId = isExternal || isWrapper || isNaN(parsedRelated) ? related?.value || related : parsedRelated;
+    const relatedContentType = relatedType ?
+        (0, lodash_1.find)(contentTypes, ct => ct.uid === relatedType) :
+        undefined;
+    const itemAttachedToMenu = menuAttached && parentAttachedToMenu;
     return {
-      ...item,
-      relatedType,
-      relatedRef: {
-        ...singleRelatedItem,
-        ...omit(relatedContentType, 'collectionName'),
-        isSingle,
-        __collectionUid: relatedContentType.uid,
-      },
+        id,
+        parent,
+        master,
+        title,
+        type,
+        updated,
+        removed,
+        order,
+        uiRouterKey,
+        collapsed,
+        menuAttached: itemAttachedToMenu,
+        audience: audience.map((audienceItem) => (0, lodash_1.isObject)(audienceItem) ? audienceItem.value : audienceItem),
+        path: isExternal ? undefined : path,
+        externalPath: isExternal ? externalPath : undefined,
+        related: isExternal || isWrapper
+            ? undefined
+            : [
+                {
+                    refId: isSingle && !relatedId ? 1 : relatedId,
+                    ref: relatedContentType ? relatedContentType.uid : relatedType,
+                    field: relatedContentType && relatedContentType.relatedField ? relatedContentType.relatedField : 'navigation',
+                },
+            ],
+        items: items.map((iItem) => (0, exports.transformItemToRESTPayload)(iItem, id, master, config, itemAttachedToMenu)),
     };
-  }
-
-  // we got empty array after remove object in relation
-  // from API we got related as array but on edit it is primitive type
-  if ((type !== navigationItemType.INTERNAL) || !related || (isObject(related) && isEmpty(related))) {
+};
+exports.transformItemToRESTPayload = transformItemToRESTPayload;
+const transformToRESTPayload = (payload, config = {}) => {
+    const { id, name, visible, items } = payload;
     return {
-      ...item,
-      ...relation,
+        id,
+        name,
+        visible,
+        items: items.map((item) => (0, exports.transformItemToRESTPayload)(item, null, id, config)),
     };
-  }
-
-  const relatedItem = isArray(related) ? last(related) : related;
-
-  const parsedRelated = Number(related);
-  const relatedId = isNaN(parsedRelated) ? related : parsedRelated;
-
-  const relationNotChanged = relatedRef && relatedItem ? relatedRef.id === relatedItem : false;
-
-  if (relationNotChanged) {
-    return item;
-  }
-
-  const shouldFindRelated = (isNumber(related) || isUuid(related) || isString(related)) && !relatedRef;
-  const shouldBuildRelated = !relatedRef || (relatedRef && (relatedRef.id !== relatedId));
-
-  if (shouldBuildRelated && !shouldFindRelated) {
-    const relatedContentType = find(contentTypes,
-      ct => ct.uid === relatedItem.__contentType, {});
-    const { uid, labelSingular, isSingle } = relatedContentType;
-    relation = {
-      related: relatedItem.id,
-      relatedRef: {
-        ...relatedItem,
-        __collectionUid: uid,
-        isSingle,
-        labelSingular,
-      },
-      relatedType: uid,
-    };
-  } else if (shouldFindRelated) {
-    const relatedRef = find(contentTypeItems, cti => cti.id === relatedId);
-    const relatedContentType = find(contentTypes, ct => ct.uid === relatedType);
-    const { uid, contentTypeName, labelSingular, isSingle } = relatedContentType;
-
-    relation = {
-      relatedRef: {
-        ...relatedRef,
-        __collectionUid: uid,
-        __contentType: contentTypeName,
-        isSingle,
-        labelSingular,
-      },
+};
+exports.transformToRESTPayload = transformToRESTPayload;
+const linkRelations = (item, config) => {
+    const { contentTypeItems = [], contentTypes = [] } = config;
+    const { type, related, relatedType, relatedRef, isSingle } = item;
+    let relation = {
+        related: undefined,
+        relatedRef: undefined,
+        relatedType: undefined,
     };
-  } else {
+    if (isSingle && relatedType) {
+        const relatedContentType = contentTypes.find(_ => relatedType === _.uid) || {};
+        const { singleRelatedItem = {} } = item;
+        return {
+            ...item,
+            relatedType,
+            relatedRef: {
+                ...singleRelatedItem,
+                ...(0, lodash_1.omit)(relatedContentType, 'collectionName'),
+                isSingle,
+                __collectionUid: relatedContentType.uid,
+            },
+        };
+    }
+    if ((type !== enums_1.navigationItemType.INTERNAL) || !related || ((0, lodash_1.isObject)(related) && (0, lodash_1.isEmpty)(related))) {
+        return {
+            ...item,
+            ...relation,
+        };
+    }
+    const relatedItem = (0, lodash_1.isArray)(related) ? (0, lodash_1.last)(related) : related;
+    const parsedRelated = Number(related);
+    const relatedId = isNaN(parsedRelated) ? related : parsedRelated;
+    const relationNotChanged = relatedRef && relatedItem ? relatedRef.id === relatedItem : false;
+    if (relationNotChanged) {
+        return item;
+    }
+    const shouldFindRelated = ((0, lodash_1.isNumber)(related) || (0, uuid_1.validate)(related) || (0, lodash_1.isString)(related)) && !relatedRef;
+    const shouldBuildRelated = !relatedRef || (relatedRef && (relatedRef.id !== relatedId));
+    if (shouldBuildRelated && !shouldFindRelated) {
+        const relatedContentType = (0, lodash_1.find)(contentTypes, ct => ct.uid === relatedItem.__contentType, {});
+        const { uid, labelSingular, isSingle } = relatedContentType;
+        relation = {
+            related: relatedItem.id,
+            relatedRef: {
+                ...relatedItem,
+                __collectionUid: uid,
+                isSingle,
+                labelSingular,
+            },
+            relatedType: uid,
+        };
+    }
+    else if (shouldFindRelated) {
+        const relatedRef = (0, lodash_1.find)(contentTypeItems, cti => cti.id === relatedId);
+        const relatedContentType = (0, lodash_1.find)(contentTypes, ct => ct.uid === relatedType);
+        const { uid, contentTypeName, labelSingular, isSingle } = relatedContentType;
+        relation = {
+            relatedRef: {
+                ...relatedRef,
+                __collectionUid: uid,
+                __contentType: contentTypeName,
+                isSingle,
+                labelSingular,
+            },
+        };
+    }
+    else {
+        return {
+            ...item,
+        };
+    }
     return {
-      ...item,
+        ...item,
+        ...relation,
     };
-  }
-
-  return {
-    ...item,
-    ...relation,
-  };
 };
-
-const reOrderItems = (items = []) =>
-  orderBy(items, ['order'], ['asc'])
+const reOrderItems = (items = []) => (0, lodash_1.orderBy)(items, ['order'], ['asc'])
     .map((item, n) => {
-      const order = n + 1;
-      return {
+    const order = n + 1;
+    return {
         ...item,
         order,
         updated: item.updated || order !== item.order,
-      };
-    });
-
-export const transformItemToViewPayload = (payload, items = [], config) => {
-  if (!payload.viewParentId) {
-    if (payload.viewId) {
-      const updatedRootLevel = items
-        .map((item) => {
-          if (item.viewId === payload.viewId) {
-            return linkRelations({
-              ...payload,
-            }, config);
-          }
-          return {
-            ...item,
-          };
-        });
-      return reOrderItems(updatedRootLevel);
-    }
-    return [
-      ...reOrderItems(items),
-      linkRelations({
-        ...payload,
-        order: items.length + 1,
-        viewId: uuid(),
-      }, config),
-    ];
-  }
-
-  const updatedLevel = items
-    .map((item) => {
-      const branchItems = item.items || [];
-      if (payload.viewParentId === item.viewId) {
-        if (!payload.viewId) {
-          return {
-            ...item,
-            items: [
-              ...reOrderItems(branchItems),
-              linkRelations({
-                ...payload,
-                order: branchItems.length + 1,
-                viewId: uuid(),
-              }, config),
-            ],
-          };
+    };
+});
+const transformItemToViewPayload = (payload, items = [], config) => {
+    if (!payload.viewParentId) {
+        if (payload.viewId) {
+            const updatedRootLevel = items
+                .map((item) => {
+                if (item.viewId === payload.viewId) {
+                    return linkRelations({
+                        ...payload,
+                    }, config);
+                }
+                return {
+                    ...item,
+                    items: (0, exports.transformItemToViewPayload)(payload, item.items, config),
+                };
+            });
+            return reOrderItems(updatedRootLevel);
         }
-        const updatedBranchItems = branchItems
-          .map((iItem) => {
-            if (iItem.viewId === payload.viewId) {
-              return linkRelations(payload, config);
+        return [
+            ...reOrderItems(items),
+            linkRelations({
+                ...payload,
+                order: items.length + 1,
+                viewId: (0, uuid_1.v4)(),
+            }, config),
+        ];
+    }
+    const updatedLevel = items
+        .map((item) => {
+        const branchItems = item.items || [];
+        if (payload.viewParentId === item.viewId) {
+            if (!payload.viewId) {
+                return {
+                    ...item,
+                    items: [
+                        ...reOrderItems(branchItems),
+                        linkRelations({
+                            ...payload,
+                            order: branchItems.length + 1,
+                            viewId: (0, uuid_1.v4)(),
+                        }, config),
+                    ],
+                };
             }
+            const updatedBranchItems = branchItems
+                .map((iItem) => {
+                if (iItem.viewId === payload.viewId) {
+                    return linkRelations(payload, config);
+                }
+                return {
+                    ...iItem,
+                };
+            });
             return {
-              ...iItem,
+                ...item,
+                items: reOrderItems(updatedBranchItems),
             };
-          });
+        }
         return {
-          ...item,
-          items: reOrderItems(updatedBranchItems),
+            ...item,
+            items: (0, exports.transformItemToViewPayload)(payload, item.items, config),
         };
-      }
-      return {
-        ...item,
-        items: transformItemToViewPayload(payload, item.items, config),
-      };
     });
-  return reOrderItems(updatedLevel);
+    return reOrderItems(updatedLevel);
 };
-
-export const prepareItemToViewPayload = (items = [], viewParentId = null, config = {}) =>
-  reOrderItems(items.map((item, n) => {
-    const viewId = uuid();
+exports.transformItemToViewPayload = transformItemToViewPayload;
+const prepareItemToViewPayload = ({ items = [], viewParentId = null, config = {}, structureIdPrefix = '' }) => reOrderItems(items.map((item, n) => {
+    const viewId = (0, uuid_1.v4)();
+    const structureId = structureIdPrefix ? `${structureIdPrefix}.${n}` : n.toString();
     return {
-      ...linkRelations({
-        viewId,
-        viewParentId,
-        ...item,
-        order: item.order || (n + 1),
-        updated: item.updated || isNil(item.order),
-      }, config),
-      items: prepareItemToViewPayload(item.items, viewId, config),
+        ...linkRelations({
+            viewId,
+            viewParentId,
+            ...item,
+            order: item.order || (n + 1),
+            structureId,
+            updated: item.updated || (0, lodash_1.isNil)(item.order),
+        }, config),
+        items: (0, exports.prepareItemToViewPayload)({
+            config,
+            items: item.items,
+            structureIdPrefix: structureId,
+            viewId,
+        }),
     };
-  }));
-
-export const extractRelatedItemLabel = (item = {}, fields = {}, config = {}) => {
-  if (get(item, 'isSingle', false)) {
-    return get(item, 'labelSingular', '');
-  }
-  const { contentTypes = [] } = config;
-  const { __collectionUid } = item;
-  const contentType = contentTypes.find(_ => _.uid === __collectionUid)
-  const { default: defaultFields = [] } = fields;
-  return get(fields, `${contentType ? contentType.uid : __collectionUid}`, defaultFields).map((_) => item[_]).filter((_) => _)[0] || '';
+}));
+exports.prepareItemToViewPayload = prepareItemToViewPayload;
+const extractRelatedItemLabel = (item = {}, fields = {}, config = {}) => {
+    if ((0, lodash_1.get)(item, 'isSingle', false)) {
+        return (0, lodash_1.get)(item, 'labelSingular', '');
+    }
+    const { contentTypes = [] } = config;
+    const { __collectionUid } = item;
+    const contentType = contentTypes.find(_ => _.uid === __collectionUid);
+    const { default: defaultFields = [] } = fields;
+    return (0, lodash_1.get)(fields, `${contentType ? contentType.uid : __collectionUid}`, defaultFields).map((_) => item[_]).filter((_) => _)[0] || '';
 };
-
-export const usedContentTypes = (items = []) => items.flatMap(
-  (item) => {
-    const used = (item.items ? usedContentTypes(item.items) : []);
+exports.extractRelatedItemLabel = extractRelatedItemLabel;
+const usedContentTypes = (items = []) => items.flatMap((item) => {
+    const used = (item.items ? (0, exports.usedContentTypes)(item.items) : []);
     if (item.relatedRef) {
-      return [item.relatedRef, ...used];
+        return [item.relatedRef, ...used];
     }
     return used;
-  },
-);
-
-export const isRelationCorrect = ({ related, type }) => {
-  const isRelationDefined = !isNil(related);
-  return type !== navigationItemType.INTERNAL || (type === navigationItemType.INTERNAL && isRelationDefined);
+});
+exports.usedContentTypes = usedContentTypes;
+const isRelationCorrect = ({ related, type }) => {
+    const isRelationDefined = !(0, lodash_1.isNil)(related);
+    return type !== enums_1.navigationItemType.INTERNAL || (type === enums_1.navigationItemType.INTERNAL && isRelationDefined);
 };
-
-export const isRelationPublished = ({ relatedRef, relatedType = {}, type, isCollection }) => {
-  if (isCollection) {
-    return relatedType.available || relatedRef.available;
-  }
-  if ((type === navigationItemType.INTERNAL)) {
-    const isHandledByPublshFlow = relatedRef ? 'published_at' in relatedRef : false;
-    if (isHandledByPublshFlow) {
-      return get(relatedRef, 'published_at', true);
+exports.isRelationCorrect = isRelationCorrect;
+const isRelationPublished = ({ relatedRef, relatedType = {}, type, isCollection }) => {
+    if (isCollection) {
+        return relatedType.available || relatedRef.available;
+    }
+    if ((type === enums_1.navigationItemType.INTERNAL)) {
+        const isHandledByPublshFlow = relatedRef ? 'published_at' in relatedRef : false;
+        if (isHandledByPublshFlow) {
+            return (0, lodash_1.get)(relatedRef, 'published_at', true);
+        }
     }
-  }
-  return true;
+    return true;
 };
-
-export const validateNavigationStructure = (items = []) =>
-  items.map(item =>
-    (
-      item.removed ||
-      isRelationCorrect({ related: item.related, type: item.type }) ||
-      (item.isSingle && isRelationCorrect({ related: item.relatedType, type: item.type }))
-    ) &&
-    validateNavigationStructure(item.items)
-  ).filter(item => !item).length === 0;
+exports.isRelationPublished = isRelationPublished;
+const validateNavigationStructure = (items = []) => items.map(item => (item.removed ||
+    (0, exports.isRelationCorrect)({ related: item.related, type: item.type }) ||
+    (item.isSingle && (0, exports.isRelationCorrect)({ related: item.relatedType, type: item.type }))) &&
+    (0, exports.validateNavigationStructure)(item.items)).filter(item => !item).length === 0;
+exports.validateNavigationStructure = validateNavigationStructure;
+//# sourceMappingURL=parsers.js.map

package/admin/src/permissions.d.ts

@@ -0,0 +1,12 @@
+export default pluginPermissions;
+declare namespace pluginPermissions {
+    const access: {
+        action: string;
+        subject: null;
+    }[];
+    const update: {
+        action: string;
+        subject: null;
+    }[];
+}
+//# sourceMappingURL=permissions.d.ts.map