@griddo/cx 11.2.8 → 11.2.9

package/build/utils/core-utils.d.ts

@@ -86,8 +86,6 @@ declare function pause(title: string): Promise<void> | undefined;
  * @param name - The name of the life cycle.
  * @param options - The arguments object.
  * @param options.steps - An array of functions to execute.
- * @param options.delay - Delay between steps functions.
- * @param options.bypass - Skip the step functions.
  * @returns - A promise that resolves when the life cycle process is completed.
  */
 declare function doLifeCycle(name: LifeCyclesNames, steps: LifeCycleSteps): Promise<void>;

package/build/utils/folders.d.ts

@@ -5,7 +5,7 @@ import { type MakeDirectoryOptions } from "fs-extra";
  *
  * @param baseDir - The base directory.
  */
-declare const clearEmptyDirs: (baseDir: string) => void;
+declare function deleteDisposableSiteDirs(): void;
 /**
  * Creates multiple directories.
  *
@@ -49,11 +49,5 @@ declare function removeArtifacts(artifacts: Array<string>): void;
  * La solución por ahora es borrarlas del store y rehacerlas en todos los renders.
  */
 declare function removeVirtualPagesFromStore(): Promise<void>;
-/**
- * Remove every .xml file in the directories in a recursive way
- * @param initialFolder - The initial folder to start the searching...
- * @deprecated - This funcion is deprecated.
- */
-declare function clearSitemapsFromDirs(initialFolder: string): void;
 declare function prependFileSync(filePath: string, content: string): void;
-export { clearEmptyDirs, clearSitemapsFromDirs, copyArtifacts, createArtifacts, moveArtifacts, prependFileSync, removeArtifacts, removeVirtualPagesFromStore, renameArtifact, };
+export { copyArtifacts, createArtifacts, deleteDisposableSiteDirs, moveArtifacts, prependFileSync, removeArtifacts, removeVirtualPagesFromStore, renameArtifact, };

package/build/utils/render.d.ts

@@ -5,11 +5,9 @@
  */
 declare function createSentinelRenderFile(): void;
 declare function deleteSentinelRenderFile(): void;
-declare function isValidRenderProcessOrThrow(): void;
-declare function initRender(): void;
-declare function finishRender(): undefined;
+declare function isValidRender(): void;
 /**
  * Send the default registers through Griddo alerts.
  */
 declare function sendGriddoDefaultAlerts(): void;
-export { createSentinelRenderFile, deleteSentinelRenderFile, finishRender, initRender, isValidRenderProcessOrThrow, sendGriddoDefaultAlerts };
+export { createSentinelRenderFile, deleteSentinelRenderFile, isValidRender, sendGriddoDefaultAlerts, };

package/build/utils/store.d.ts

@@ -30,10 +30,6 @@ declare function getBuildPagesPath(): string[];
  * Get the build metadata from the Store.
  */
 declare function getBuildMetadata(): Promise<BuildMetaData>;
-/**
- * Creates an `store` dir to store pages transformed by createStore
- */
-declare function createStoreDir(): void;
 /**
  * Write render info into a file.
  * @param renderInfo - Data that will be saved related to the render process.
@@ -54,61 +50,32 @@ declare function getPageInStoreDir(basePath: string): Array<number>;
  * Save the pages into the file system.
  * @param pages - An array of Griddo page objects to be saved.
  */
-declare function savePagesInStore(siteFolderName: string, pages: Array<GriddoPageObject>): void;
-/**
- * Remove files from dir.
- * @param filenames - An array of ids representing file page names.
- */
-declare function removeSitePagesFromStore(siteDirName: string, filenames: Array<number>): void;
-/**
- * Returns pages that need to be created or deleted for a site in the store based on the provided arguments.
- * @param sitePages - Properties for page retrieval.
- * @param props.storeDir - Absolute path of the Griddo store.
- * @param props.pages - Exhaustive array of all pages in the site.
- * @param props.validPagesIds - Array of valid pages in the site.
- * @param props.changedPages - Array of pages that have been modified in the site.
- * @returns - An object containing the pages to be created and deleted in the site.
- */
-declare function getSitePagesToCreateOrDelete(sitePages: {
-    sitesToPublish: Array<Site>;
-    validPagesIds: Array<number>;
-    changedPages: Array<number>;
-    siteDirName: string;
-}): Promise<{
-    pagesInStore: number[];
-    pagesMissingInStore: number[];
-    pagesToDeleteFromStore: number[];
-    pagesToWriteToStore: number[];
-}>;
-/**
- * Returns pages that need to be created or deleted for a site in the store based on the provided arguments.
- * @param sitePages - Properties for page retrieval.
- * @param props.storeDir - Absolute path of the Griddo store.
- * @param props.pages - Exhaustive array of all pages in the site.
- * @param props.validPagesIds - Array of valid pages in the site.
- * @param props.changedPages - Array of pages that have been modified in the site.
- * @returns - An object containing the pages to be created and deleted in the site.
- */
-declare function getSitePagesToCreateOrDeleteCached(sitePages: {
-    sitesToPublish: Array<Site>;
-    validPagesIds: Array<number>;
-    changedPages: Array<number>;
-    siteDirName: string;
-    domain: string;
-}): Promise<{
-    pagesInStore: number[];
-    pagesMissingInStore: number[];
-    pagesToDeleteFromStore: number[];
-    pagesToWriteToStore: number[];
-}>;
+declare function saveSitePagesInStore(siteDirName: string, pages: Array<GriddoPageObject>): void;
 /**
- * Removes sites from store that are not in `sitesToPublish` array.
+ * Removes JSON files from the specified site directory based on the provided arrays of page numbers.
+ * For each number in the arrays, a corresponding file with the format `<number>.json` is removed if it exists.
+ *
+ * WARNING: This function may end up handling large arrays, so don't be tempted
+ * to refactor it to use something cool like the spread operator and make a
+ * single array, etc..
+ *
+ * @param siteDirName - The name of the site directory containing the pages.
+ * @param pageIdsArray - A two-dimensional array where each inner array contains numbers representing page files to be removed.
  */
-declare function deleteZombieSitesFoldersFromStore(sitesToPublish: Array<Site>): void;
+declare function removeSitePagesFromStore(siteDirName: string, pageIdsArray: Array<Array<number>>): void;
 /**
  * Removes sites that exist in the store that should no longer be there because
  * the domain has been changed. This is necessary because those sites will not
  * be marked as `sitesToUnpublish` so they must be removed manually.
  */
 declare function removeOrphanSites(sitesToPublish: Array<Site>, domain: string): void;
-export { createStoreDir, deleteZombieSitesFoldersFromStore, getBuildMetadata, getBuildPagesFromCachedStore, getBuildPagesFromStore, getBuildPagesPath, getPageInStoreDir, getSitePagesToCreateOrDelete, getSitePagesToCreateOrDeleteCached, removeOrphanSites, removeSitePagesFromStore, savePagesInStore, saveRenderInfoInStore, };
+/**
+ * Returns the list of `activePages` pages that do not currently exist in a
+ * site's store (probably due to a failed render).
+ */
+declare function getMissingPublishedPagesInStore(siteName: string, activePages: Array<number>): number[];
+/**
+ * Get pages that are not active anymore but are in the store.
+ */
+declare function getZombiePagesInStore(siteDir: string, pages: Array<number>): number[];
+export { getBuildMetadata, getBuildPagesFromCachedStore, getBuildPagesFromStore, getBuildPagesPath, getMissingPublishedPagesInStore, getPageInStoreDir, getZombiePagesInStore, removeOrphanSites, removeSitePagesFromStore, saveSitePagesInStore, saveRenderInfoInStore, };

package/exporter/adapters/gatsby/index.ts

@@ -21,9 +21,9 @@ import {
 } from "../../utils/core-utils";
 import { createDomainRenderData } from "../../utils/create-build-data";
 import {
-	clearEmptyDirs,
 	copyArtifacts,
 	createArtifacts,
+	deleteDisposableSiteDirs,
 	moveArtifacts,
 	removeArtifacts,
 	removeVirtualPagesFromStore,
@@ -33,7 +33,7 @@ import { infoLog } from "../../utils/loggin";
 import {
 	createSentinelRenderFile,
 	deleteSentinelRenderFile,
-	isValidRenderProcessOrThrow,
+	isValidRender,
 } from "../../utils/render";
 
 /**
@@ -135,7 +135,7 @@ export async function renderDomainsWithGatsbyAdapter(domain: string) {
 			name: "Archive",
 			steps: [
 				() => removeVirtualPagesFromStore(),
-				() => clearEmptyDirs(path.join(__cx, "dist")),
+				() => deleteDisposableSiteDirs(),
 				() =>
 					moveArtifacts(__cx, __exports, cxArtifacts.archivables, {
 						withBackup: true,
@@ -146,16 +146,13 @@ export async function renderDomainsWithGatsbyAdapter(domain: string) {
 		},
 
 		{
-			name: "Clean",
+			name: "Close",
 			steps: [() => removeArtifacts(disposableArtifacts)],
 		},
 
 		{
 			name: "HealthCheck",
-			steps: [
-				() => isValidRenderProcessOrThrow(),
-				() => deleteSentinelRenderFile(),
-			],
+			steps: [() => isValidRender(), () => deleteSentinelRenderFile()],
 		},
 	];
 

package/exporter/constants/index.ts

@@ -112,18 +112,18 @@ const envs = {
 };
 
 const lifeCycleNames: Record<LifeCyclesNames, LifeCyclesNames> = {
-	Init: "Init",
-	HealthCheck: "HealthCheck",
 	__DEBUG__: "__DEBUG__",
+	Archive: "Archive",
 	Clean: "Clean",
 	Close: "Close",
+	Data: "Data",
+	HealthCheck: "HealthCheck",
+	Init: "Init",
+	Meta: "Meta",
 	Prepare: "Prepare",
+	Relocation: "Relocation",
 	Restore: "Restore",
-	Data: "Data",
 	SSG: "SSG",
-	Relocation: "Relocation",
-	Meta: "Meta",
-	Archive: "Archive",
 } as const;
 
 export { endpoints, envs, lifeCycleNames };

package/exporter/services/sites.ts

@@ -19,8 +19,10 @@ import { get, post } from "../utils/api";
 /**
  * Get a list of site objects.
  */
-async function getAllSites() {
-	return await get<AllSitesReponse>({ endpoint: endpoints.GET_ALL });
+async function getAllSites(domain: string) {
+	return await get<AllSitesReponse>({
+		endpoint: `${endpoints.GET_ALL}?domainSlug=${domain}`,
+	});
 }
 
 /**

package/exporter/services/store.ts

@@ -18,8 +18,8 @@ import { getReferenceFieldData } from "./reference-fields";
 import { getAllSettings } from "./settings";
 import { getPage } from "./sites";
 import { updatedSiteHash } from "../utils/cache";
-import { getConfig } from "../utils/core-utils";
-import { buildLog, listSitesLog, verboseLog } from "../utils/loggin";
+import { getConfig, removeAllSiteDirsFromStore } from "../utils/core-utils";
+import { buildLog, listSitesLog } from "../utils/loggin";
 import {
 	createGriddoListPages,
 	createGriddoMultiPages,
@@ -29,36 +29,27 @@ import {
 } from "../utils/pages";
 import { getSiteData, getSitesToRender, unpublishSites } from "../utils/sites";
 import {
-	createStoreDir,
+	getMissingPublishedPagesInStore,
+	getZombiePagesInStore,
 	removeOrphanSites,
-	savePagesInStore,
-	saveRenderInfoInStore,
-} from "../utils/store";
-import {
-	deleteZombieSitesFoldersFromStore,
-	getSitePagesToCreateOrDelete,
 	removeSitePagesFromStore,
+	saveRenderInfoInStore,
+	saveSitePagesInStore,
 } from "../utils/store";
 
-const config = getConfig();
-
-// Envs
-const RENDER_ID = new Date().valueOf().toString();
+const renderId = new Date().valueOf().toString();
+const { griddoVersion, paths } = getConfig();
+const { __cx } = paths();
+const storeDir = path.join(__cx, "store");
 
 /**
  * Fetch, process and save object pages and sites data into the file system to
  * be consumed by other services (Griddo itself, Adapters, etc.)
  */
 async function createStore(domain: string) {
-	createStoreDir();
-
 	console.info(`API calls with ${envs.GRIDDO_API_CONCURRENCY_COUNT} threads`);
 	console.info(`API URL ${envs.GRIDDO_API_URL as string}`);
 
-	const { __cx } = config.paths();
-	const { griddoVersion } = config;
-	const storeDir = path.join(__cx, "store");
-
 	try {
 		// Vars to save later in the report file
 		const createdPages: Array<number> = [];
@@ -67,6 +58,13 @@ async function createStore(domain: string) {
 		// Get sites objects to publish and unpublish from this domain
 		const { sitesToPublish, sitesToUnpublish } = await getSitesToRender(domain);
 
+		const domainHasSites =
+			sitesToPublish.length > 0 || sitesToUnpublish.length > 0;
+
+		if (!domainHasSites) {
+			console.warn(`There are no sites to update in the domain ${domain}`);
+		}
+
 		listSitesLog("Sites to publish:", sitesToPublish);
 		listSitesLog("Sites to unpublish:", sitesToUnpublish);
 
@@ -83,11 +81,11 @@ async function createStore(domain: string) {
 
 		// Solo los sites to publish...
 		for (const site of sitesToPublish) {
-			const { id: siteId, slug: siteSlug, theme, favicon, changedPages = [] } = site;
+			const { id: siteId, slug: siteSlug, theme, favicon, pagesStatus } = site;
+			const siteDirName = siteId.toString();
 
 			const {
 				siteInfo,
-				validPagesIds,
 				siteHash,
 				unpublishHashes,
 				siteLangs,
@@ -156,7 +154,7 @@ async function createStore(domain: string) {
 			buildLog(`${site.name} site`);
 
 			/// Creates the store directory for each site using the id
-			fs.mkdirSync(path.join(storeDir, siteId.toString()), {
+			fs.mkdirSync(path.join(storeDir, siteDirName), {
 				recursive: true,
 			});
 
@@ -165,7 +163,10 @@ async function createStore(domain: string) {
 			// -------------------------------------------------------------------------
 			// Async function that process every page for one site to use later in the
 			// `Promise.all` with pLimit.
-			const fetchSitePageAndSaveInStore = async (siteIdName: string, pageId: number) => {
+			const fetchSitePageAndSaveInStore = async (
+				siteIdName: string,
+				pageId: number,
+			) => {
 				// Here will be store every page returned by the API and processed
 				let griddoPageObjects: Array<GriddoPageObject> = [];
 
@@ -184,7 +185,9 @@ async function createStore(domain: string) {
 				// SHAME: This new pageAdditionalInfo needs to be a copy because
 				// additionalInfo referenced from outside this function and
 				// its used by other pages.
-				const pageAdditionalInfo = JSON.parse(JSON.stringify(additionalInfo)) as PageAdditionalInfo;
+				const pageAdditionalInfo = JSON.parse(
+					JSON.stringify(additionalInfo),
+				) as PageAdditionalInfo;
 
 				// Updated with navigations (header & footer)
 				pageAdditionalInfo.navigations = NavService.getPageNavigations(page);
@@ -196,7 +199,7 @@ async function createStore(domain: string) {
 				// fetch for the data.
 				const template = await getReferenceFieldData({
 					page,
-					cacheKey: RENDER_ID,
+					cacheKey: renderId,
 				});
 
 				// MultiPage Query
@@ -214,7 +217,8 @@ async function createStore(domain: string) {
 				// - Single: just one page
 
 				// Griddo page types
-				const isStaticListPage = page?.mode === "list" || page?.mode === "paginated-data";
+				const isStaticListPage =
+					page?.mode === "list" || page?.mode === "paginated-data";
 				const isMultiPage = !isStaticListPage && multiPageElements;
 				const isSinglePage = !isMultiPage && !isStaticListPage;
 
@@ -230,7 +234,10 @@ async function createStore(domain: string) {
 					} as GriddoListPage;
 
 					// pageObjects = await createGriddoListPages({ adapter: "Gatsby" })
-					griddoPageObjects = await createGriddoListPages(griddoListPage, pageAdditionalInfo);
+					griddoPageObjects = await createGriddoListPages(
+						griddoListPage,
+						pageAdditionalInfo,
+					);
 				}
 
 				// >> Multi-page <<
@@ -242,7 +249,10 @@ async function createStore(domain: string) {
 					griddoMultipage.multiPageElements = multiPageElements;
 					griddoMultipage.defaultLang = defaultLang;
 
-					griddoPageObjects = await createGriddoMultiPages(griddoMultipage, pageAdditionalInfo);
+					griddoPageObjects = await createGriddoMultiPages(
+						griddoMultipage,
+						pageAdditionalInfo,
+					);
 				}
 
 				// >> Single template <<
@@ -253,7 +263,9 @@ async function createStore(domain: string) {
 					griddoSinglePage.template = template;
 					griddoSinglePage.defaultLang = defaultLang;
 
-					griddoPageObjects = [await createGriddoSinglePage(griddoSinglePage, pageAdditionalInfo)];
+					griddoPageObjects = [
+						await createGriddoSinglePage(griddoSinglePage, pageAdditionalInfo),
+					];
 				}
 
 				// Upload only the valid pages hashes or ids of pages that has
@@ -264,49 +276,80 @@ async function createStore(domain: string) {
 				}
 
 				// Save build data to store
-				savePagesInStore(siteIdName, griddoPageObjects);
+				saveSitePagesInStore(siteIdName, griddoPageObjects);
 			};
 
-			// Pages to be created or deleted in the store
-			const { pagesMissingInStore, pagesToDeleteFromStore, pagesToWriteToStore } =
-				await getSitePagesToCreateOrDelete({
-					sitesToPublish,
-					validPagesIds,
-					changedPages,
-					siteDirName: siteId.toString(),
-				});
-
-			// 1 - Delete pages from the store (just remove from disk)
-			removeSitePagesFromStore(siteId.toString(), pagesToDeleteFromStore);
-
-			// 2 - Create pages to the store (fetch from API, transform, etc..)
+			// Pages that needs to be fetched from the API and written to the
+			// store.
+			const pagesToFetchFromAPI = [
+				// These pages are news or has been updated.
+				...pagesStatus.uploadPending,
+				// You should take into account the pages that, even though they are
+				// already published and therefore should be avoided from requesting
+				// them to the API, are not in the store, probably due to a failed
+				// render. In that case, you have to request them again from the API
+				// to include them in the store.
+				...getMissingPublishedPagesInStore(siteDirName, pagesStatus.active),
+			];
+
+			// Create pages to the store. First requesting from API,
+			// transform, etc., and then writing them to disk.
 			const limit = pLimit(envs.GRIDDO_API_CONCURRENCY_COUNT);
-			const pagesToStore = pagesToWriteToStore.map((id: number) =>
-				limit(() => fetchSitePageAndSaveInStore(siteId.toString(), id)),
+			const pagesToStore = pagesToFetchFromAPI.map((id: number) =>
+				limit(() => fetchSitePageAndSaveInStore(siteDirName, id)),
 			);
 
-			// Debug time
-			verboseLog(`Store site: ${site.name}`);
-			verboseLog(`${validPagesIds.length} valid pages from API`);
-			verboseLog(`changed ${changedPages.length} pages from API`);
-			verboseLog(`deleted ${pagesToDeleteFromStore.length} pages from store`);
-			verboseLog(`missing ${pagesMissingInStore.length} pages in store`);
-			verboseLog(`write ${pagesToWriteToStore.length} pages to store`);
-
 			await Promise.all(pagesToStore);
+
+			// @ts-expect-error Mutate pagesStatus for reading pourposes.
+			pagesStatus.zombie = getZombiePagesInStore(siteDirName, [
+				...pagesStatus.active,
+				...pagesStatus.uploadPending,
+			]);
+
+			// Delete pages from the store removing them from disk.
+			removeSitePagesFromStore(siteDirName, [
+				pagesStatus.deleted,
+				pagesStatus.offline,
+				pagesStatus.offlinePending,
+				// @ts-expect-error Mutate pagesStatus for reading pourposes.
+				pagesStatus.zombie,
+			]);
 		}
 
-		// Remove zombie sites from store
-		deleteZombieSitesFoldersFromStore(sitesToPublish);
-
-		// Después de renderizar todos los sites y sus páginas (las que sean que
-		// hayan cambiado etc.) guardamos un archivo con la información del
-		// render para usos posteriores.
-		saveRenderInfoInStore({
-			buildProcessData,
-			createdPages,
-			sitesToPublish,
-		});
+		// Después de guardar en el store todos los sites y sus páginas (las que
+		// sean que hayan cambiado etc.) guardamos un archivo con la información
+		// del render para usos posteriores.
+
+		// Tenemos dos casos:
+
+		// ( 1 ) - Render de dominios con sites para publicar o despublicar. Se
+		// guarda la infor del render normalmente.
+
+		// ( 2 ) - Render de un dominio que no tiene sites ni para publicar ni para
+		// despublicar, lo que llamamos un dominio "vacío".
+		// Entonces se eliminan las páginas "huérfanas" de la carpeta `store`
+		// así el proceso de SSG se encontrará efectivamente con un dominio "sin
+		// páginas" y "borrará" lo que exista en ese momento en el store para
+		// ese dominio y se guarda la información del render con arrays vacíos
+		// directamente en `createdPages` y `sitesToPublish`.
+
+		if (domainHasSites) {
+			// ( 1 )
+			saveRenderInfoInStore({
+				buildProcessData,
+				createdPages,
+				sitesToPublish,
+			});
+		} else {
+			// ( 2 )
+			removeAllSiteDirsFromStore();
+			saveRenderInfoInStore({
+				buildProcessData,
+				createdPages: [],
+				sitesToPublish: [],
+			});
+		}
 	} catch (e) {
 		const error = e as { message: string };
 		console.error(error.message);

package/exporter/types/sites.ts

@@ -51,6 +51,13 @@ export interface Site
 	siteScript: string;
 	smallAvatar: string;
 	updated: boolean;
+	pagesStatus: {
+		active: Array<number>;
+		uploadPending: Array<number>;
+		offlinePending: Array<number>;
+		offline: Array<number>;
+		deleted: Array<number>;
+	};
 }
 
 export interface SiteData {

package/exporter/utils/core-utils.ts

@@ -304,8 +304,6 @@ function pause(title: string) {
  * @param name - The name of the life cycle.
  * @param options - The arguments object.
  * @param options.steps - An array of functions to execute.
- * @param options.delay - Delay between steps functions.
- * @param options.bypass - Skip the step functions.
  * @returns - A promise that resolves when the life cycle process is completed.
  */
 async function doLifeCycle(name: LifeCyclesNames, steps: LifeCycleSteps) {

package/exporter/utils/folders.ts

@@ -16,53 +16,25 @@ const config = getConfig();
  *
  * @param baseDir - The base directory.
  */
-const clearEmptyDirs = (baseDir: string) => {
-	const isDir = fsx.statSync(baseDir).isDirectory();
-	if (!isDir) {
+function deleteDisposableSiteDirs() {
+	const { __cx } = config.paths();
+	const baseDir = path.join(__cx, "dist");
+
+	if (!fs.existsSync(baseDir)) {
 		return;
 	}
 
-	// archivos o direvtorios dentro de `dir`
-	let children = fsx.readdirSync(baseDir);
-	// let children = childrenRaw.filter((file) => {
-	// 	return path.extname(file).toLowerCase() !== ".xml";
-	// });
-	const dirHasChildren = children.length > 0;
-
-	// Por cada uno de ellos miramos si tiene hijos, enviamos cada uno de ellos
-	// a `clearEmptyDirsWithXML`
-	if (dirHasChildren) {
-		const childrenCount = children.length;
-		const xmlCount = children.filter((file) => {
-			return path.extname(file).toLowerCase() === ".xml";
-		}).length;
-
-		// Todos los hijos son archivos .xml
-		// Podemos borrarlos y dejar el dir vacío.
-		if (childrenCount === xmlCount) {
-			for (const xmlFile of children) {
-				const fullPath = path.join(baseDir, xmlFile);
-				fsx.rmSync(fullPath);
-			}
-			children = fsx.readdirSync(baseDir);
-		}
+	const sitesDirs = fs
+		.readdirSync(baseDir, { withFileTypes: true })
+		.filter((file) => file.isDirectory());
 
-		for (const file of children) {
-			const fullPath = path.join(baseDir, file);
-			clearEmptyDirs(fullPath);
+	for (const siteDir of sitesDirs) {
+		const sitePath = path.join(baseDir, siteDir.name);
+		if (siteIsEmpty(sitePath)) {
+			fs.rmSync(sitePath, { recursive: true });
 		}
-
-		// re-evaluate files; after deleting subdir we may have parent dir
-		// empty now...
-		children = fsx.readdirSync(baseDir);
 	}
-
-	// Si no tiene hijos, lo borramos
-	if (children.length === 0) {
-		fsx.rmdirSync(baseDir);
-		return;
-	}
-};
+}
 
 /**
  * Creates multiple directories.
@@ -307,38 +279,23 @@ async function removeVirtualPagesFromStore() {
 }
 
 /**
- * Remove every .xml file in the directories in a recursive way
- * @param initialFolder - The initial folder to start the searching...
- * @deprecated - This funcion is deprecated.
+ * Return true if the site folder is empty or only has xml files. (Recursively)
  */
-function clearSitemapsFromDirs(initialFolder: string) {
-	// Recursively remove .xml files
+function siteIsEmpty(sitePath: string) {
+	const siteFiles = fs
+		.readdirSync(sitePath, {
+			withFileTypes: true,
+			recursive: true,
+		})
+		.filter(
+			(file) => file.isFile() && !path.basename(file.name).startsWith("."),
+		);
 
-	function removeXmlFiles(folder: string): void {
-		try {
-			// Read the content of the directory
-			const files = fs.readdirSync(folder);
-			// Iterate over each file/folder in the directory
-			for (const file of files) {
-				const fullPath = path.join(folder, file);
-				// Check if the current path is a directory or file
-				const stats = fs.statSync(fullPath);
-				if (stats.isDirectory()) {
-					// Recursively call removeXmlFiles if it's a directory
-					removeXmlFiles(fullPath);
-				} else if (stats.isFile() && path.extname(fullPath) === ".xml") {
-					// Remove the file if it's an .xml file
-					fs.unlinkSync(fullPath);
-				}
-			}
-		} catch (error) {
-			console.error(error);
-			throw new Error(`Error processing directory: ${folder}`);
-		}
-	}
+	const xmlFiles = siteFiles.filter((file) => file.name.endsWith(".xml"));
 
-	// Start the process from the initial folder
-	removeXmlFiles(initialFolder);
+	if (siteFiles.length === xmlFiles.length) {
+		return true;
+	}
 }
 
 function prependFileSync(filePath: string, content: string) {
@@ -352,10 +309,9 @@ function prependFileSync(filePath: string, content: string) {
 }
 
 export {
-	clearEmptyDirs,
-	clearSitemapsFromDirs,
 	copyArtifacts,
 	createArtifacts,
+	deleteDisposableSiteDirs,
 	moveArtifacts,
 	prependFileSync,
 	removeArtifacts,