@webbio/strapi-plugin-page-builder 0.12.1-platform → 0.12.2-platform

package/admin/src/components/StrapiCore/admin/admin/src/content-manager/components/Relations/RelationInputDataManager.tsx

@@ -1,6 +1,6 @@
-const PUBLICATION_STATES = {
-	DRAFT: 'draft',
-	PUBLISHED: 'published'
-} as const;
-
-export { PUBLICATION_STATES };
+const PUBLICATION_STATES = {
+	DRAFT: 'draft',
+	PUBLISHED: 'published'
+} as const;
+
+export { PUBLICATION_STATES };

package/admin/src/components/StrapiCore/admin/admin/src/content-manager/components/Relations/useRelation.ts

@@ -1,170 +1,170 @@
-// @ts-nocheck build compiler thinks differently than runtime compiler
-import { useEffect, useState } from 'react';
-
-import { useCallbackRef, useFetchClient } from '@strapi/helper-plugin';
-import { useInfiniteQuery } from 'react-query';
-
-import { NormalizeRelationArgs, NormalizedRelation, normalizeRelations } from './utils/normalizeRelations';
-
-import type { Contracts } from '../../../../../../content-manager/shared';
-
-interface UseRelationArgs {
-	relation: {
-		enabled: boolean;
-		endpoint: string;
-		normalizeArguments: NormalizeRelationArgs;
-		onLoad: (data: NormalizedRelation[]) => void;
-		pageParams?: Record<string, any>;
-		pageGoal?: number;
-	};
-	search: {
-		endpoint: string;
-		pageParams?: Record<string, any>;
-	};
-}
-
-const useRelation = (cacheKey: any[] = [], { relation, search }: UseRelationArgs) => {
-	const [searchParams, setSearchParams] = useState({});
-	const [currentPage, setCurrentPage] = useState(0);
-	const { get } = useFetchClient();
-
-	const { onLoad: onLoadRelations, normalizeArguments } = relation;
-
-	const relationsRes = useInfiniteQuery(
-		['relation', ...cacheKey],
-		async ({ pageParam = 1 }) => {
-			try {
-				const { data } = await get<Contracts.Relations.FindExisting.Response>(relation?.endpoint, {
-					params: {
-						...(relation.pageParams ?? {}),
-						page: pageParam
-					}
-				});
-
-				setCurrentPage(pageParam);
-
-				return data;
-			} catch (err) {
-				return null;
-			}
-		},
-		{
-			cacheTime: 0,
-			enabled: relation.enabled,
-			getNextPageParam(lastPage) {
-				const isXToOneRelation = lastPage && !('pagination' in lastPage);
-
-				if (
-					!lastPage || // the API may send an empty 204 response
-					isXToOneRelation || // xToOne relations do not have a pagination
-					lastPage?.pagination.page >= lastPage?.pagination.pageCount
-				) {
-					return undefined;
-				}
-
-				// eslint-disable-next-line consistent-return
-				return lastPage.pagination.page + 1;
-			},
-			select: (data) => ({
-				...data,
-				pages: data.pages.map((page) => {
-					if (!page) {
-						return page;
-					}
-
-					let normalizedResults: Contracts.Relations.RelationResult[] = [];
-
-					// xToOne relations return an object, which we normalize so that relations
-					// always have the same shape
-					if ('data' in page && page.data) {
-						normalizedResults = [page.data];
-					} else if ('results' in page && page.results) {
-						normalizedResults = [...page.results].reverse();
-					}
-
-					return {
-						pagination: 'pagination' in page ? page.pagination : undefined,
-						results: normalizedResults
-					};
-				})
-			})
-		}
-	);
-
-	const { pageGoal } = relation;
-
-	const { status, data, fetchNextPage, hasNextPage } = relationsRes;
-
-	useEffect(() => {
-		/**
-		 * This ensures the infiniteQuery hook fetching has caught-up with the modifiedData
-		 * state i.e. in circumstances where you add 10 relations, the browserState knows this,
-		 * but the hook would think it could fetch more, when in reality, it can't.
-		 */
-		if (pageGoal && pageGoal > currentPage && hasNextPage && status === 'success') {
-			fetchNextPage({
-				pageParam: currentPage + 1
-			});
-		}
-	}, [pageGoal, currentPage, fetchNextPage, hasNextPage, status]);
-
-	const onLoadRelationsCallback = useCallbackRef(onLoadRelations);
-
-	useEffect(() => {
-		if (status === 'success' && data && data.pages?.at(-1)?.results && onLoadRelationsCallback) {
-			// everytime we fetch, we normalize prior to adding to redux
-			const normalizedResults = normalizeRelations(data.pages.at(-1)?.results ?? [], normalizeArguments);
-
-			// this is loadRelation from EditViewDataManagerProvider
-			onLoadRelationsCallback(normalizedResults);
-		}
-
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [status, onLoadRelationsCallback, data]);
-
-	const searchRes = useInfiniteQuery(
-		['relation', ...cacheKey, 'search', JSON.stringify(searchParams)],
-		async ({ pageParam = 1 }) => {
-			try {
-				const { data } = await get<Contracts.Relations.FindAvailable.Response>(search.endpoint, {
-					params: {
-						...(search.pageParams ?? {}),
-						...searchParams,
-						page: pageParam
-					}
-				});
-
-				return data;
-			} catch (err) {
-				return null;
-			}
-		},
-		{
-			enabled: Object.keys(searchParams).length > 0,
-			getNextPageParam(lastPage) {
-				if (
-					!lastPage?.pagination ||
-					(lastPage.pagination && lastPage.pagination.page >= lastPage.pagination.pageCount)
-				) {
-					return undefined;
-				}
-
-				// eslint-disable-next-line consistent-return
-				return lastPage.pagination.page + 1;
-			}
-		}
-	);
-
-	const searchFor = (term: string, options: object = {}) => {
-		setSearchParams({
-			...options,
-			_q: term,
-			_filter: '$containsi'
-		});
-	};
-
-	return { relations: relationsRes, search: searchRes, searchFor };
-};
-
-export { useRelation };
-export type { UseRelationArgs };
+// @ts-nocheck build compiler thinks differently than runtime compiler
+import { useEffect, useState } from 'react';
+
+import { useCallbackRef, useFetchClient } from '@strapi/helper-plugin';
+import { useInfiniteQuery } from 'react-query';
+
+import { NormalizeRelationArgs, NormalizedRelation, normalizeRelations } from './utils/normalizeRelations';
+
+import type { Contracts } from '../../../../../../content-manager/shared';
+
+interface UseRelationArgs {
+	relation: {
+		enabled: boolean;
+		endpoint: string;
+		normalizeArguments: NormalizeRelationArgs;
+		onLoad: (data: NormalizedRelation[]) => void;
+		pageParams?: Record<string, any>;
+		pageGoal?: number;
+	};
+	search: {
+		endpoint: string;
+		pageParams?: Record<string, any>;
+	};
+}
+
+const useRelation = (cacheKey: any[] = [], { relation, search }: UseRelationArgs) => {
+	const [searchParams, setSearchParams] = useState({});
+	const [currentPage, setCurrentPage] = useState(0);
+	const { get } = useFetchClient();
+
+	const { onLoad: onLoadRelations, normalizeArguments } = relation;
+
+	const relationsRes = useInfiniteQuery(
+		['relation', ...cacheKey],
+		async ({ pageParam = 1 }) => {
+			try {
+				const { data } = await get<Contracts.Relations.FindExisting.Response>(relation?.endpoint, {
+					params: {
+						...(relation.pageParams ?? {}),
+						page: pageParam
+					}
+				});
+
+				setCurrentPage(pageParam);
+
+				return data;
+			} catch (err) {
+				return null;
+			}
+		},
+		{
+			cacheTime: 0,
+			enabled: relation.enabled,
+			getNextPageParam(lastPage) {
+				const isXToOneRelation = lastPage && !('pagination' in lastPage);
+
+				if (
+					!lastPage || // the API may send an empty 204 response
+					isXToOneRelation || // xToOne relations do not have a pagination
+					lastPage?.pagination.page >= lastPage?.pagination.pageCount
+				) {
+					return undefined;
+				}
+
+				// eslint-disable-next-line consistent-return
+				return lastPage.pagination.page + 1;
+			},
+			select: (data) => ({
+				...data,
+				pages: data.pages.map((page) => {
+					if (!page) {
+						return page;
+					}
+
+					let normalizedResults: Contracts.Relations.RelationResult[] = [];
+
+					// xToOne relations return an object, which we normalize so that relations
+					// always have the same shape
+					if ('data' in page && page.data) {
+						normalizedResults = [page.data];
+					} else if ('results' in page && page.results) {
+						normalizedResults = [...page.results].reverse();
+					}
+
+					return {
+						pagination: 'pagination' in page ? page.pagination : undefined,
+						results: normalizedResults
+					};
+				})
+			})
+		}
+	);
+
+	const { pageGoal } = relation;
+
+	const { status, data, fetchNextPage, hasNextPage } = relationsRes;
+
+	useEffect(() => {
+		/**
+		 * This ensures the infiniteQuery hook fetching has caught-up with the modifiedData
+		 * state i.e. in circumstances where you add 10 relations, the browserState knows this,
+		 * but the hook would think it could fetch more, when in reality, it can't.
+		 */
+		if (pageGoal && pageGoal > currentPage && hasNextPage && status === 'success') {
+			fetchNextPage({
+				pageParam: currentPage + 1
+			});
+		}
+	}, [pageGoal, currentPage, fetchNextPage, hasNextPage, status]);
+
+	const onLoadRelationsCallback = useCallbackRef(onLoadRelations);
+
+	useEffect(() => {
+		if (status === 'success' && data && data.pages?.at(-1)?.results && onLoadRelationsCallback) {
+			// everytime we fetch, we normalize prior to adding to redux
+			const normalizedResults = normalizeRelations(data.pages.at(-1)?.results ?? [], normalizeArguments);
+
+			// this is loadRelation from EditViewDataManagerProvider
+			onLoadRelationsCallback(normalizedResults);
+		}
+
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [status, onLoadRelationsCallback, data]);
+
+	const searchRes = useInfiniteQuery(
+		['relation', ...cacheKey, 'search', JSON.stringify(searchParams)],
+		async ({ pageParam = 1 }) => {
+			try {
+				const { data } = await get<Contracts.Relations.FindAvailable.Response>(search.endpoint, {
+					params: {
+						...(search.pageParams ?? {}),
+						...searchParams,
+						page: pageParam
+					}
+				});
+
+				return data;
+			} catch (err) {
+				return null;
+			}
+		},
+		{
+			enabled: Object.keys(searchParams).length > 0,
+			getNextPageParam(lastPage) {
+				if (
+					!lastPage?.pagination ||
+					(lastPage.pagination && lastPage.pagination.page >= lastPage.pagination.pageCount)
+				) {
+					return undefined;
+				}
+
+				// eslint-disable-next-line consistent-return
+				return lastPage.pagination.page + 1;
+			}
+		}
+	);
+
+	const searchFor = (term: string, options: object = {}) => {
+		setSearchParams({
+			...options,
+			_q: term,
+			_filter: '$containsi'
+		});
+	};
+
+	return { relations: relationsRes, search: searchRes, searchFor };
+};
+
+export { useRelation };
+export type { UseRelationArgs };

package/admin/src/components/StrapiCore/admin/admin/src/content-manager/components/Relations/utils/getRelationLink.ts

@@ -1,5 +1,5 @@
-import { Entity } from '@strapi/types';
-
-export function getRelationLink(targetModel: string, id?: Entity.ID) {
-	return `/content-manager/collectionType/${targetModel}/${id ?? ''}`;
-}
+import { Entity } from '@strapi/types';
+
+export function getRelationLink(targetModel: string, id?: Entity.ID) {
+	return `/content-manager/collectionType/${targetModel}/${id ?? ''}`;
+}

package/admin/src/components/StrapiCore/admin/admin/src/content-manager/components/Relations/utils/normalizeRelations.ts

@@ -1,52 +1,52 @@
-// @ts-nocheck build compiler thinks differently than runtime compiler
-import type { Contracts } from '../../../../../../../content-manager/shared';
-
-import { PUBLICATION_STATES } from '../RelationInputDataManager';
-
-import { getRelationLink } from './getRelationLink';
-
-export interface NormalizeRelationArgs {
-	shouldAddLink: boolean;
-	mainFieldName: string;
-	targetModel: string;
-}
-
-export type NormalizedRelation = Contracts.Relations.RelationResult & {
-	href?: string;
-	mainField: string;
-	publicationState?: false | 'published' | 'draft';
-};
-
-export const normalizeRelation = (
-	relation: Contracts.Relations.RelationResult,
-	{ shouldAddLink, mainFieldName, targetModel }: NormalizeRelationArgs
-) => {
-	const nextRelation: NormalizedRelation = {
-		...relation,
-		mainField: relation[mainFieldName]
-	};
-
-	if (shouldAddLink) {
-		nextRelation.href = getRelationLink(targetModel, nextRelation.id);
-	}
-
-	nextRelation.publicationState = false;
-
-	if (nextRelation?.publishedAt !== undefined) {
-		nextRelation.publicationState = nextRelation.publishedAt ? PUBLICATION_STATES.PUBLISHED : PUBLICATION_STATES.DRAFT;
-	}
-
-	return nextRelation;
-};
-
-/*
- * Applies some transformations to existing and new relations in order to display them correctly
- * relations: raw relations data coming from useRelations
- * shouldAddLink: comes from generateRelationQueryInfos, if true we display a link to the relation (TO FIX: explanation)
- * mainFieldName: name of the main field inside the relation (e.g. text field), if no displayable main field exists (e.g. date field) we use the id of the entry
- * targetModel: the model on which the relation is based on, used to create an URL link
- */
-
-export const normalizeRelations = (relations: Contracts.Relations.RelationResult[], args: NormalizeRelationArgs) => {
-	return [...relations].map((relation) => normalizeRelation(relation, args));
-};
+// @ts-nocheck build compiler thinks differently than runtime compiler
+import type { Contracts } from '../../../../../../../content-manager/shared';
+
+import { PUBLICATION_STATES } from '../RelationInputDataManager';
+
+import { getRelationLink } from './getRelationLink';
+
+export interface NormalizeRelationArgs {
+	shouldAddLink: boolean;
+	mainFieldName: string;
+	targetModel: string;
+}
+
+export type NormalizedRelation = Contracts.Relations.RelationResult & {
+	href?: string;
+	mainField: string;
+	publicationState?: false | 'published' | 'draft';
+};
+
+export const normalizeRelation = (
+	relation: Contracts.Relations.RelationResult,
+	{ shouldAddLink, mainFieldName, targetModel }: NormalizeRelationArgs
+) => {
+	const nextRelation: NormalizedRelation = {
+		...relation,
+		mainField: relation[mainFieldName]
+	};
+
+	if (shouldAddLink) {
+		nextRelation.href = getRelationLink(targetModel, nextRelation.id);
+	}
+
+	nextRelation.publicationState = false;
+
+	if (nextRelation?.publishedAt !== undefined) {
+		nextRelation.publicationState = nextRelation.publishedAt ? PUBLICATION_STATES.PUBLISHED : PUBLICATION_STATES.DRAFT;
+	}
+
+	return nextRelation;
+};
+
+/*
+ * Applies some transformations to existing and new relations in order to display them correctly
+ * relations: raw relations data coming from useRelations
+ * shouldAddLink: comes from generateRelationQueryInfos, if true we display a link to the relation (TO FIX: explanation)
+ * mainFieldName: name of the main field inside the relation (e.g. text field), if no displayable main field exists (e.g. date field) we use the id of the entry
+ * targetModel: the model on which the relation is based on, used to create an URL link
+ */
+
+export const normalizeRelations = (relations: Contracts.Relations.RelationResult[], args: NormalizeRelationArgs) => {
+	return [...relations].map((relation) => normalizeRelation(relation, args));
+};

package/admin/src/components/StrapiCore/admin/admin/src/content-manager/constants/attributes.ts

@@ -1,3 +1,3 @@
-const CREATOR_FIELDS = ['createdBy', 'updatedBy'];
-
-export { CREATOR_FIELDS };
+const CREATOR_FIELDS = ['createdBy', 'updatedBy'];
+
+export { CREATOR_FIELDS };