@griddo/ax 11.10.23 → 11.10.24

package/src/containers/Sites/actions.tsx

@@ -1,69 +1,69 @@
+import { analytics, dataPack, languages, pages, sites, social, structuredData } from "@ax/api";
+import { analyticsActions } from "@ax/containers/Analytics";
+import { appActions } from "@ax/containers/App";
+import { integrationsActions } from "@ax/containers/Integrations";
+import { menuActions, navigationActions } from "@ax/containers/Navigation";
+import { resetPageEditor } from "@ax/containers/PageEditor/actions";
+import { dataPacksActions } from "@ax/containers/Settings/DataPacks";
+import { socialActions } from "@ax/containers/Settings/Social";
+import { structuredDataActions } from "@ax/containers/StructuredData";
+import { usersActions } from "@ax/containers/Users";
+import { getDefaultTheme, getThemeElements, handleRequest, isReqOk, sortBy } from "@ax/helpers";
+import {
+	IGetGlobalPagesParams,
+	IGetSitePagesParams,
+	IGetSitesParams,
+	IPage,
+	IQueryValue,
+	IRootState,
+	ISettingsForm,
+	ISite,
+	ISiteListConfig,
+	IThemeElements,
+} from "@ax/types";
+
 import { Dispatch } from "redux";
+
 import {
-	SET_SITES,
-	SET_RECENT_SITES,
-	SET_SITES_BY_LANG,
+	DEFAULT_PARAMS,
+	SET_ALL_SITE_PAGES,
+	SET_CONFIG,
+	SET_CONTENT_FILTERS,
+	SET_CURRENT_SEARCH,
+	SET_CURRENT_SITE_ERROR_PAGES,
 	SET_CURRENT_SITE_INFO,
+	SET_CURRENT_SITE_LANGUAGES,
 	SET_CURRENT_SITE_PAGES,
-	SET_ALL_SITE_PAGES,
 	SET_FILTER,
-	SET_TOTAL_ITEMS,
-	SET_SITES_TOTAL_ITEMS,
-	SET_CURRENT_SITE_LANGUAGES,
+	SET_IS_SITES_LOADING,
+	SET_RECENT_SITES,
 	SET_SAVED_SITE_INFO,
-	DEFAULT_PARAMS,
-	SET_CURRENT_SITE_ERROR_PAGES,
-	SET_CONTENT_FILTERS,
-	SET_CONFIG,
-	SET_CURRENT_SEARCH,
+	SET_SITES,
+	SET_SITES_BY_LANG,
+	SET_SITES_TOTAL_ITEMS,
 	SET_THEME_ELEMENTS,
-	SET_IS_SITES_LOADING,
+	SET_TOTAL_ITEMS,
 } from "./constants";
-
 import {
-	ISetSitesAction,
-	ISetRecentSitesAction,
-	ISetSitesByLangAction,
+	ISetAllSitePagesAction,
+	ISetConfig,
+	ISetContentFilters,
+	ISetCurrentSearch,
+	ISetCurrentSiteErrorPages,
 	ISetCurrentSiteInfoAction,
+	ISetCurrentSiteLanguagesAction,
 	ISetCurrentSitePagesAction,
-	ISetAllSitePagesAction,
 	ISetFilter,
-	ISetTotalItems,
-	ISetCurrentSiteLanguagesAction,
+	ISetIsSitesLoading,
+	ISetRecentSitesAction,
 	ISetSavedSiteInfoAction,
-	ISetCurrentSiteErrorPages,
-	ISetContentFilters,
+	ISetSitesAction,
+	ISetSitesByLangAction,
 	ISetSitesTotalItems,
-	ISetConfig,
-	ISetCurrentSearch,
 	ISetThemeElements,
-	ISetIsSitesLoading,
+	ISetTotalItems,
 } from "./interfaces";
 
-import {
-	ISite,
-	IGetSitePagesParams,
-	ISettingsForm,
-	IGetGlobalPagesParams,
-	IPage,
-	IGetSitesParams,
-	ISiteListConfig,
-	IQueryValue,
-	IThemeElements,
-	IRootState,
-} from "@ax/types";
-import { sites, languages, dataPack, social, structuredData, analytics, pages } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { structuredDataActions } from "@ax/containers/StructuredData";
-import { navigationActions, menuActions } from "@ax/containers/Navigation";
-import { resetPageEditor } from "@ax/containers/PageEditor/actions";
-import { analyticsActions } from "@ax/containers/Analytics";
-import { dataPacksActions } from "@ax/containers/Settings/DataPacks";
-import { socialActions } from "@ax/containers/Settings/Social";
-import { integrationsActions } from "@ax/containers/Integrations";
-import { getDefaultTheme, getThemeElements, handleRequest, isReqOk, sortBy } from "@ax/helpers";
-import { usersActions } from "@ax/containers/Users";
-
 const { setIsSaving, setLanguage } = appActions;
 const { resetDefaultsValues, getDefaults } = navigationActions;
 const { resetMenuValues } = menuActions;

package/src/forms/editor.tsx

@@ -1,5 +1,5 @@
-import { deepClone, getSchema, getDisplayName, getTemplate } from "@ax/helpers";
-import { IPage, IBreadcrumbItem } from "@ax/types";
+import { deepClone, getDisplayName, getSchema, getTemplate } from "@ax/helpers";
+import type { IBreadcrumbItem, IPage } from "@ax/types";
 
 const configKeys = ["headerConfig", "footerConfig"];
 
@@ -213,8 +213,9 @@ const evaluateComputedFields = async (page: IPage, operation: "save" | "refresh"
 		apiUrl: process.env.GRIDDO_API_URL || process.env.REACT_APP_API_ENDPOINT,
 		publicApiUrl: process.env.GRIDDO_PUBLIC_API_URL || process.env.REACT_APP_PUBLIC_API_ENDPOINT,
 	};
-	for (const field of pageSchemaContent) {
+	for (const field of pageSchemaContent || []) {
 		if (Object.prototype.hasOwnProperty.call(field, "computed")) {
+			// biome-ignore lint/security/noGlobalEval: we need to evaluate the computed field
 			const computedFunction = eval(`(${field.computed})`);
 			updatedPage.template[field.key] = await computedFunction(page, data);
 		}

package/src/helpers/index.tsx

@@ -1,130 +1,112 @@
+import { arrayInsert, isEmptyArray, moveArrayElement } from "./arrays";
 import {
-	isComponentEmpty,
-	setAsContainedComponent,
 	areAllComponentsEmpty,
-	isEmptyContainer,
 	areEqual,
+	isComponentEmpty,
+	isEmptyContainer,
+	setAsContainedComponent,
 } from "./containerEvaluations";
-
+import { getMaxColumns, updateColumns } from "./customColumns";
+import { getActivatedDataPacksIds, getDeactivatedModules, isModuleDisabled } from "./dataPacks";
 import {
-	filterImageText,
-	camelize,
-	splitCamelCase,
-	slugify,
-	validateEmail,
-	capitalize,
-	getInitials,
-	trimText,
-	decodeEntities,
-	isNumber,
-	getFileExtension,
-	splitAndJoin,
-	splitAndTrim,
-	copyTextToClipboard,
-	stripHtml,
-} from "./strings";
-
+	areEqualDates,
+	dateToString,
+	getDateRange,
+	getDaysAgo,
+	getFormattedDateWithTimezone,
+	getHumanLastModifiedDate,
+	getRange,
+	getScheduleFormatDate,
+	getStringifyDateRange,
+	isValidDate,
+	isValidDateRange,
+	stringToDate,
+} from "./dates";
+import { isDevelopment } from "./environment";
+import { getFieldByPath } from "./fields";
+import { getFileIcon, getNewBreadcrumb, updatePropertyById } from "./files";
+import { protectFormKeys } from "./forms";
+import { compressImage, imageResizeCropAndCompress } from "./imageResize";
+import { formatBytes, getImageFromHtml, getImageFromIFrame, imageToBase64 } from "./images";
 import {
-	isEmptyObj,
+	areEquals,
 	deepClone,
-	isSelectedEditorID,
-	resetMultipleValues,
+	encodeData,
 	filterDuplicatedValues,
-	areEquals,
-	removeMenuEditorIds,
-	sortBy,
+	findObjectValue,
 	getNullValue,
-	removeEditorIds,
-	trimObject,
 	hasProps,
-	encodeData,
-	findObjectValue,
+	isEmptyObj,
+	isSelectedEditorID,
 	removeDuplicatesByProperty,
+	removeEditorIds,
+	removeMenuEditorIds,
+	resetMultipleValues,
+	sortBy,
+	trimObject,
 } from "./objects";
-
+import { parseTheme } from "./parseTheme";
+import { delay, handleRequest, isReqOk } from "./requests";
 import {
-	getSchema,
+	filterByCategory,
+	getDataPackSchema,
+	getDefaultFormTemplate,
+	getDefaultNavigationModules,
 	getDefaultSchema,
-	getTemplate,
 	getDefaultTemplate,
 	getDisplayName,
-	getTemplateType,
-	getTemplateDisplayName,
+	getFormTemplate,
+	getFormTemplateCategories,
+	getFormTemplates,
+	getFormTemplateThumbnails,
 	getMenuItems,
-	filterByCategory,
-	getSchemaType,
 	getModuleCategories,
 	getModuleStyles,
-	getDataPackSchema,
+	getNavigationModules,
+	getSchema,
+	getSchemaFormCategories,
 	getSchemaThumbnails,
+	getSchemaType,
+	getTemplate,
+	getTemplateDisplayName,
 	getTemplateThumbnails,
-	getNavigationModules,
-	getDefaultNavigationModules,
+	getTemplateType,
 	isMultipleNavigationModules,
-	getFormTemplate,
-	getDefaultFormTemplate,
-	getFormTemplates,
-	getFormTemplateThumbnails,
-	getSchemaFormCategories,
-	getFormTemplateCategories,
 } from "./schemas";
-
 import {
-	getStructuredDataFromPage,
+	camelize,
+	capitalize,
+	copyTextToClipboard,
+	decodeEntities,
+	filterImageText,
+	getFileExtension,
+	getInitials,
+	isNumber,
+	slugify,
+	splitAndJoin,
+	splitAndTrim,
+	splitCamelCase,
+	stripHtml,
+	trimText,
+	validateEmail,
+} from "./strings";
+import {
 	getCurrentPageStructuredData,
+	getGlobalPageTypes,
+	getStructuredDataFromPage,
 	getStructuredDataTitle,
-	isStructuredDataFromPage,
 	isGlobalStructuredData,
-	getGlobalPageTypes,
+	isStructuredDataFromPage,
 } from "./structuredData";
-
-import { getThumbnailProps, getFormTemplateThumbnailProps } from "./thumbnails";
-
-import { getFieldByPath } from "./fields";
-
-import { formatBytes, imageToBase64, getImageFromHtml, getImageFromIFrame } from "./images";
-
-import { isReqOk, handleRequest, delay } from "./requests";
-
 import {
-	dateToString,
-	stringToDate,
-	isValidDate,
-	isValidDateRange,
-	getDateRange,
-	areEqualDates,
-	getStringifyDateRange,
-	getHumanLastModifiedDate,
-	getFormattedDateWithTimezone,
-	getDaysAgo,
-	getRange,
-	getScheduleFormatDate,
-} from "./dates";
-
-import { imageResizeCropAndCompress, compressImage } from "./imageResize";
-
-import { isEmptyArray, moveArrayElement, arrayInsert } from "./arrays";
-
-import { getActivatedDataPacksIds, isModuleDisabled, getDeactivatedModules } from "./dataPacks";
-
-import { isDevelopment } from "./environment";
-
-import {
-	getDefaultTheme,
-	getThemeElements,
+	filterThemeDatapacks,
 	filterThemeModules,
 	filterThemeTemplates,
-	filterThemeDatapacks,
+	getDefaultTheme,
+	getThemeElements,
 	isTemplateExcludedFromTheme,
 } from "./themes";
-
-import { parseTheme } from "./parseTheme";
-
-import { getFileIcon, getNewBreadcrumb, updatePropertyById } from "./files";
-
-import { getMaxColumns, updateColumns } from "./customColumns";
-
-import { protectFormKeys } from "./forms";
+import { getFormTemplateThumbnailProps, getThumbnailProps } from "./thumbnails";
 
 export {
 	isComponentEmpty,

package/src/helpers/schemas.tsx

@@ -1,23 +1,87 @@
 import { sortBy } from "@ax/helpers";
-import { pageSchemas } from "@ax/schemas";
-import { ISchema, ModuleCategoryInfo } from "@ax/types";
-import { config } from "components";
+import { getPageSchemas } from "@ax/schemas";
+import { schemasService } from "@ax/services";
+import type { ISchema, ModuleCategoryInfo } from "@ax/types";
+
+//////////////////
+const getUISchemas = () => {
+	if (!schemasService.isLoaded()) {
+		return { modules: {}, components: {}, templates: {} };
+	}
+	try {
+		const schemas = schemasService.getSchemas();
+		return schemas.ui;
+	} catch (e) {
+		console.error(`[helpers/schemas] getUISchemas failed to get schemas:`, e);
+		return { modules: {}, components: {}, templates: {} };
+	}
+};
 
-const schemas = config.schemas.ui;
-const schemasConfig = config.schemas.config;
-const formSchemas = config.schemas.forms;
-const contentTypesSchemas = config.schemas.contentTypes;
-const moduleCategories = config.schemas.config.moduleCategories;
-const allSchemas = {
-	...schemas.modules,
-	...schemas.components,
-	...formSchemas?.fields,
-	...pageSchemas,
+const getSchemasConfig = () => {
+	if (!schemasService.isLoaded()) {
+		return { menuItems: {}, moduleCategories: [] };
+	}
+	try {
+		return schemasService.getSchemas().config;
+	} catch (e) {
+		console.error(`[helpers/schemas] getSchemasConfig failed to get schemas:`, e);
+		return { menuItems: {}, moduleCategories: [] };
+	}
+};
+
+const getFormSchemas = () => {
+	if (!schemasService.isLoaded()) {
+		return undefined;
+	}
+	try {
+		return schemasService.getSchemas().forms;
+	} catch (e) {
+		console.error(`[helpers/schemas] getFormSchemas failed to get schemas:`, e);
+		return undefined;
+	}
 };
 
-const getSchema = (name: string): ISchema | undefined => allSchemas[name];
+const getContentTypesSchemas = () => {
+	if (!schemasService.isLoaded()) {
+		return { dataPacks: {} };
+	}
+	try {
+		return schemasService.getSchemas().contentTypes;
+	} catch (e) {
+		console.error(`[helpers/schemas] getContentTypesSchemas failed to get schemas:`, e);
+		return { dataPacks: {} };
+	}
+};
+
+const getAllSchemas = () => {
+	const uiSchemas = getUISchemas();
+	const formSchemas = getFormSchemas();
+	const pageSchemas = getPageSchemas();
+
+	return {
+		...uiSchemas.modules,
+		...uiSchemas.components,
+		...formSchemas?.fields,
+		...pageSchemas,
+	};
+};
+
+//////////////////
+
+const getSchema = (name: string): ISchema | undefined => {
+	try {
+		const allSchemas = getAllSchemas();
+		// @ts-expect-error TODO: fix this, before was `any`
+		return allSchemas[name];
+	} catch (e) {
+		console.error(`[helpers/schemas] getSchema(${name}) failed:`, e);
+		return undefined;
+	}
+};
 
 const getDefaultSchema = (name: string) => {
+	const allSchemas = getAllSchemas();
+	// @ts-expect-error TODO: fix this, before was `any`
 	const defaultSchema = allSchemas[name] ? allSchemas[name].default : {};
 
 	for (const key of Object.keys(defaultSchema)) {
@@ -28,7 +92,7 @@ const getDefaultSchema = (name: string) => {
 		) {
 			defaultSchema[key] = getDefaultSchema(defaultSchema[key].schema);
 		}
-		if (defaultSchema[key] instanceof Array) {
+		if (Array.isArray(defaultSchema[key])) {
 			for (const i in defaultSchema[key]) {
 				if (
 					defaultSchema[key][i] &&
@@ -45,38 +109,71 @@ const getDefaultSchema = (name: string) => {
 };
 
 const getSchemaThumbnails = (name: string, theme?: string) => {
-	if (!allSchemas[name]?.thumbnails) return null;
+	const allSchemas = getAllSchemas();
+	// @ts-expect-error TODO: fix this, before was `any`
+	if (!allSchemas[name]?.thumbnails) {
+		return null;
+	}
 
+	// @ts-expect-error TODO: fix this, before was `any`
 	return theme && allSchemas[name].thumbnails[theme] ? allSchemas[name].thumbnails[theme] : allSchemas[name].thumbnails;
 };
 
-const getTemplate = (name: string) => schemas.templates[name];
+const getTemplate = (name: string) => {
+	const schemas = getUISchemas();
+	return schemas.templates[name];
+};
 
-const getDefaultTemplate = (name: string) => schemas.templates[name].default;
+const getDefaultTemplate = (name: string) => {
+	const schemas = getUISchemas();
+	return schemas.templates[name].default;
+};
 
-const getFormTemplates = (): Record<string, ISchema> => formSchemas?.templates || {};
+const getFormTemplates = (): Record<string, ISchema> => {
+	const formSchemas = getFormSchemas();
+	return formSchemas?.templates || {};
+};
 
-const getFormTemplate = (name: string): ISchema | undefined => formSchemas?.templates[name];
+const getFormTemplate = (name: string): ISchema | undefined => {
+	const formSchemas = getFormSchemas();
+	return formSchemas?.templates?.[name];
+};
 
-const getDefaultFormTemplate = (name: string): Record<string, any> | undefined => formSchemas?.templates[name]?.default;
+const getDefaultFormTemplate = (name: string): Record<string, any> | undefined => {
+	const formSchemas = getFormSchemas();
+	return formSchemas?.templates?.[name]?.default;
+};
 
-const getSchemaFormCategories = (): { label: string; value: string; featured?: boolean }[] =>
-	formSchemas?.categories || [];
+function getSchemaFormCategories(): { label: string; value: string; featured?: boolean }[] {
+	const formSchemas = getFormSchemas();
+	return formSchemas?.categories || [];
+}
 
-const getFormTemplateCategories = (): { label: string; value: string }[] => formSchemas?.templateCategories || [];
+const getFormTemplateCategories = (): { label: string; value: string }[] => {
+	const formSchemas = getFormSchemas();
+	return formSchemas?.templateCategories || [];
+};
 
-const getTemplateThumbnails = (name: string, theme?: string) => {
-	if (!schemas.templates[name]?.thumbnails) return null;
+const getTemplateThumbnails = (name: string, theme?: string): any => {
+	const schemas = getUISchemas();
+	if (!schemas.templates?.[name]?.thumbnails) {
+		return null;
+	}
 
-	return theme && schemas.templates[name].thumbnails[theme]
-		? schemas.templates[name].thumbnails[theme]
-		: schemas.templates[name] && schemas.templates[name].thumbnails;
+	return theme && schemas.templates?.[name]?.thumbnails?.[theme]
+		? schemas.templates?.[name]?.thumbnails?.[theme]
+		: schemas.templates?.[name]?.thumbnails;
 };
 
-const getFormTemplateThumbnails = (name: string): Record<string, string> | null =>
-	formSchemas?.templates[name]?.thumbnails ? formSchemas?.templates[name].thumbnails : null;
+const getFormTemplateThumbnails = (name: string): Record<string, string> | null => {
+	const formSchemas = getFormSchemas();
+	return formSchemas?.templates?.[name]?.thumbnails || null;
+};
 
-const getDataPackSchema = (name: string) => contentTypesSchemas.dataPacks[name];
+const getDataPackSchema = (name: string) => {
+	const contentTypesSchemas = getContentTypesSchemas();
+	return contentTypesSchemas.dataPacks[name];
+};
 
 const getDisplayName = (component: string): string => {
 	const schema = getSchema(component);
@@ -89,7 +186,7 @@ const getSchemaType = (component: string) => {
 };
 
 const getTemplateType = (template: string) => {
-	const { type } = getTemplate(template);
+	const { type } = getTemplate(template) || {};
 	return type;
 };
 
@@ -98,13 +195,22 @@ const getTemplateDisplayName = (template: string) => {
 	return schema ? schema.displayName : undefined;
 };
 
-const getMenuItems = (type: string): { fields: any[] } | undefined => schemasConfig.menuItems[type];
+const getMenuItems = (type: string): { fields: any[] } | undefined => {
+	const schemasConfig = getSchemasConfig();
+	// @ts-expect-error TODO: fix this, before was `any`
+	return schemasConfig.menuItems[type];
+};
 
-const filterByCategory = (options: any, category: string) =>
-	options.filter((option: any) => allSchemas[option]?.category === category);
+const filterByCategory = (options: any, category: string) => {
+	const allSchemas = getAllSchemas();
+	// @ts-expect-error TODO: fix this, before was `any`
+	return options.filter((option: any) => allSchemas[option]?.category === category);
+};
 
 const getModuleCategories = (moduleList: string[]): ModuleCategoryInfo[] => {
 	const categories: string[] = [];
+	const schemasConfig = getSchemasConfig();
+	const moduleCategories = schemasConfig.moduleCategories || [];
 
 	const allCategory: ModuleCategoryInfo = {
 		label: "All",
@@ -118,6 +224,7 @@ const getModuleCategories = (moduleList: string[]): ModuleCategoryInfo[] => {
 			const foundCategory = moduleCategories.find((category: ModuleCategoryInfo) => category.value === categoryValue);
 
 			if (foundCategory) {
+				// @ts-expect-error TODO: fix this, before was `any`
 				categories.push(foundCategory);
 			}
 		}
@@ -145,6 +252,7 @@ const getModuleStyles = (module: string): any[] => {
 
 const getNavigationModules = (): Record<string, any[]> => {
 	const navigationModules: Record<string, any[]> = { header: [], footer: [] };
+	const schemas = getUISchemas();
 	Object.keys(schemas.modules).forEach((key: string) => {
 		const moduleType = schemas.modules[key].type;
 		if (["header", "footer"].includes(moduleType)) {

package/src/helpers/structuredData.tsx

@@ -1,6 +1,4 @@
-import { config } from "components";
-
-const schemas = config.schemas.contentTypes;
+import { schemasService } from "@ax/services";
 
 const getStructuredDataFromPage = (site: any) => site.filter((data: any) => data.fromPage);
 
@@ -9,18 +7,49 @@ const getCurrentPageStructuredData = (template: string, structuredDataFromPage:
 		(data: any) => !!data.schema.templates.find((relatedTemplate: string) => relatedTemplate === template),
 	);
 
-const getStructuredDataTitle = (name: string): string => schemas.structuredData[name]?.title;
+const getStructuredDataTitle = (name: string): string => {
+	if (!schemasService.isLoaded()) {
+		return "";
+	}
+	const schemas = schemasService.getSchemas().contentTypes;
+	// Asumiendo que structuredData está en contentTypes... TODO: fix the type...
+	const structuredData = (schemas as any).structuredData;
+	return structuredData?.[name]?.title || "";
+};
 
-const isStructuredDataFromPage = (name: string): boolean => schemas.structuredData[name]?.fromPage;
+const isStructuredDataFromPage = (name: string): boolean => {
+	if (!schemasService.isLoaded()) {
+		return false;
+	}
+	const schemas = schemasService.getSchemas().contentTypes;
+	const structuredData = (schemas as any).structuredData;
+	return structuredData?.[name]?.fromPage || false;
+};
 
-const isGlobalStructuredData = (name: string): boolean => !schemas.structuredData[name]?.local;
+const isGlobalStructuredData = (name: string): boolean => {
+	if (!schemasService.isLoaded()) {
+		return false;
+	}
+	const schemas = schemasService.getSchemas().contentTypes;
+	const structuredData = (schemas as any).structuredData;
+	return !structuredData?.[name]?.local;
+};
 
 const getGlobalPageTypes = (): Record<string, string>[] => {
-	const { structuredData } = schemas;
+	if (!schemasService.isLoaded()) {
+		return [];
+	}
+
+	const schemas = schemasService.getSchemas().contentTypes;
+	const structuredData = (schemas as any).structuredData;
+	if (!structuredData) {
+		return [];
+	}
 	const keys = Object.keys(structuredData);
 	const globalPageTypes = keys.reduce((arr: Record<string, string>[], type: string) => {
 		const title = structuredData[type].title;
 		const isGlobalPage = structuredData[type].fromPage && !structuredData[type].local;
+		// biome-ignore lint/performance/noAccumulatingSpread: TODO: fix this
 		return isGlobalPage ? [...arr, { type, title }] : arr;
 	}, []);
 	return globalPageTypes;