@schalkneethling/miyagi-core 4.4.2 → 4.4.3

package/lib/state/file-contents.js

@@ -16,8 +16,8 @@ import log from "../logger.js";
  * @returns {boolean}
  */
 function isSchemaFile(fileName) {
-	const schemaFileName = `${global.config.files.schema.name}.${global.config.files.schema.extension}`;
-	return path.basename(fileName) === schemaFileName;
+  const schemaFileName = `${global.config.files.schema.name}.${global.config.files.schema.extension}`;
+  return path.basename(fileName) === schemaFileName;
 }
 
 /**
@@ -25,15 +25,15 @@ function isSchemaFile(fileName) {
  * @param {Error & { code?: string }} err
  */
 function markFileReadError(fileName, err) {
-	if (!global.state?.fileReadErrors || !isSchemaFile(fileName)) {
-		return;
-	}
-
-	global.state.fileReadErrors[fileName] = {
-		type: "schema-parse",
-		code: err?.code || null,
-		message: err?.message || String(err),
-	};
+  if (!global.state?.fileReadErrors || !isSchemaFile(fileName)) {
+    return;
+  }
+
+  global.state.fileReadErrors[fileName] = {
+    type: "schema-parse",
+    code: err?.code || null,
+    message: err?.message || String(err),
+  };
 }
 
 /**
@@ -43,7 +43,7 @@ function markFileReadError(fileName, err) {
  * @returns {boolean} is true if given array includes given file path
  */
 function checkIfFileNamesIncludeFile(file, fileNames) {
-	return fileNames.includes(path.basename(file));
+  return fileNames.includes(path.basename(file));
 }
 
 /**
@@ -52,46 +52,46 @@ function checkIfFileNamesIncludeFile(file, fileNames) {
  * @returns {Promise<string[]>}
  */
 async function getFilePaths(sourceTree) {
-	const { assets, components, files } = global.config;
-
-	const paths = [...assets.customProperties.files];
-
-	if (sourceTree.components) {
-		(function getPaths(entry) {
-			if (!anymatch(components.ignores, entry.path)) {
-				if (entry.type === "file") {
-					if (
-						checkIfFileNamesIncludeFile(entry.path, [
-							`${helpers.getResolvedFileName(
-								files.templates.name,
-								path.basename(entry.path, `.${files.templates.extension}`),
-							)}.${files.templates.extension}`,
-							`${files.mocks.name}.${files.mocks.extension[0]}`,
-							`${files.mocks.name}.${files.mocks.extension[1]}`,
-							`${files.schema.name}.${files.schema.extension}`,
-						]) ||
-						helpers.fileIsDocumentationFile(entry.path)
-					) {
-						paths.push(entry.path);
-					}
-				} else if (entry.type === "directory") {
-					entry.children.forEach((item) => getPaths(item));
-				}
-			}
-		})(sourceTree.components);
-	}
-
-	if (sourceTree.docs) {
-		(function getPaths(entry) {
-			if (entry.type === "file") {
-				paths.push(entry.path);
-			} else if (entry.type === "directory") {
-				entry.children.forEach((item) => getPaths(item));
-			}
-		})(sourceTree.docs);
-	}
-
-	return paths;
+  const { assets, components, files } = global.config;
+
+  const paths = [...assets.customProperties.files];
+
+  if (sourceTree.components) {
+    (function getPaths(entry) {
+      if (!anymatch(components.ignores, entry.path)) {
+        if (entry.type === "file") {
+          if (
+            checkIfFileNamesIncludeFile(entry.path, [
+              `${helpers.getResolvedFileName(
+                files.templates.name,
+                path.basename(entry.path, `.${files.templates.extension}`),
+              )}.${files.templates.extension}`,
+              `${files.mocks.name}.${files.mocks.extension[0]}`,
+              `${files.mocks.name}.${files.mocks.extension[1]}`,
+              `${files.schema.name}.${files.schema.extension}`,
+            ]) ||
+            helpers.fileIsDocumentationFile(entry.path)
+          ) {
+            paths.push(entry.path);
+          }
+        } else if (entry.type === "directory") {
+          entry.children.forEach((item) => getPaths(item));
+        }
+      }
+    })(sourceTree.components);
+  }
+
+  if (sourceTree.docs) {
+    (function getPaths(entry) {
+      if (entry.type === "file") {
+        paths.push(entry.path);
+      } else if (entry.type === "directory") {
+        entry.children.forEach((item) => getPaths(item));
+      }
+    })(sourceTree.docs);
+  }
+
+  return paths;
 }
 
 /**
@@ -101,9 +101,9 @@ async function getFilePaths(sourceTree) {
  * @returns {Promise<string>} - the default export of the ES module
  */
 async function getJsFileContent(fileName) {
-	const file = await import(path.resolve(`${fileName}?time=${Date.now()}`));
+  const file = await import(path.resolve(`${fileName}?time=${Date.now()}`));
 
-	return file.default();
+  return file.default();
 }
 
 /**
@@ -112,12 +112,12 @@ async function getJsFileContent(fileName) {
  * @returns {Promise<object>} the content of the given file as an object
  */
 async function getYamlFileContent(fileName) {
-	try {
-		const result = await readFileFs(fileName, "utf8");
-		return yaml.load(result);
-	} catch (err) {
-		return Promise.reject(err);
-	}
+  try {
+    const result = await readFileFs(fileName, "utf8");
+    return yaml.load(result);
+  } catch (err) {
+    return Promise.reject(err);
+  }
 }
 
 /**
@@ -126,12 +126,12 @@ async function getYamlFileContent(fileName) {
  * @returns {Promise<object>} the parsed content of the given file
  */
 async function getParsedJsonFileContent(fileName) {
-	try {
-		const result = await readFileFs(fileName, "utf8");
-		return JSON.parse(result);
-	} catch (err) {
-		return Promise.reject(err);
-	}
+  try {
+    const result = await readFileFs(fileName, "utf8");
+    return JSON.parse(result);
+  } catch (err) {
+    return Promise.reject(err);
+  }
 }
 
 /**
@@ -140,12 +140,12 @@ async function getParsedJsonFileContent(fileName) {
  * @returns {Promise<string>} the markdown of the given file converted into HTML
  */
 async function getConvertedMarkdownFileContent(fileName) {
-	try {
-		const result = await readFileFs(fileName, "utf8");
-		return Markdown.parse(result);
-	} catch (err) {
-		return Promise.reject(err);
-	}
+  try {
+    const result = await readFileFs(fileName, "utf8");
+    return Markdown.parse(result);
+  } catch (err) {
+    return Promise.reject(err);
+  }
 }
 
 /**
@@ -155,67 +155,67 @@ async function getConvertedMarkdownFileContent(fileName) {
  * @returns {Promise<string|object|Array>} content of the given file based on its type
  */
 export const readFile = async function (fileName) {
-	switch (true) {
-		case [".yaml", ".yml"].includes(path.extname(fileName)):
-			{
-				try {
-					const content = await getYamlFileContent(fileName);
-					if (global.state?.fileReadErrors) {
-						delete global.state.fileReadErrors[fileName];
-					}
-					return content;
-				} catch (err) {
-					markFileReadError(fileName, err);
-					log("error", `Error when reading file ${fileName}`, err);
-				}
-			}
-			break;
-		case helpers.fileIsDocumentationFile(fileName):
-			{
-				try {
-					return await getConvertedMarkdownFileContent(fileName);
-				} catch (err) {
-					log("error", `Error when reading file ${fileName}`, err);
-				}
-			}
-			break;
-		case helpers.fileIsDataFile(fileName) &&
-			[".js", ".mjs"].includes(path.extname(fileName)):
-			{
-				try {
-					const content = await getJsFileContent(fileName);
-					if (global.state?.fileReadErrors) {
-						delete global.state.fileReadErrors[fileName];
-					}
-					return content;
-				} catch (err) {
-					markFileReadError(fileName, err);
-					log("error", `Error when reading file ${fileName}`, err);
-				}
-			}
-			break;
-		case fileName.endsWith(".json"):
-			{
-				try {
-					const content = await getParsedJsonFileContent(fileName);
-					if (global.state?.fileReadErrors) {
-						delete global.state.fileReadErrors[fileName];
-					}
-					return content;
-				} catch (err) {
-					markFileReadError(fileName, err);
-					log("error", `Error when reading file ${fileName}`, err);
-				}
-			}
-			break;
-		default: {
-			try {
-				return await readFileFs(fileName, { encoding: "utf8" });
-			} catch (err) {
-				log("error", `Error when reading file ${fileName}`, err);
-			}
-		}
-	}
+  switch (true) {
+    case [".yaml", ".yml"].includes(path.extname(fileName)):
+      {
+        try {
+          const content = await getYamlFileContent(fileName);
+          if (global.state?.fileReadErrors) {
+            delete global.state.fileReadErrors[fileName];
+          }
+          return content;
+        } catch (err) {
+          markFileReadError(fileName, err);
+          log("error", `Error when reading file ${fileName}`, err);
+        }
+      }
+      break;
+    case helpers.fileIsDocumentationFile(fileName):
+      {
+        try {
+          return await getConvertedMarkdownFileContent(fileName);
+        } catch (err) {
+          log("error", `Error when reading file ${fileName}`, err);
+        }
+      }
+      break;
+    case helpers.fileIsDataFile(fileName) &&
+      [".js", ".mjs"].includes(path.extname(fileName)):
+      {
+        try {
+          const content = await getJsFileContent(fileName);
+          if (global.state?.fileReadErrors) {
+            delete global.state.fileReadErrors[fileName];
+          }
+          return content;
+        } catch (err) {
+          markFileReadError(fileName, err);
+          log("error", `Error when reading file ${fileName}`, err);
+        }
+      }
+      break;
+    case fileName.endsWith(".json"):
+      {
+        try {
+          const content = await getParsedJsonFileContent(fileName);
+          if (global.state?.fileReadErrors) {
+            delete global.state.fileReadErrors[fileName];
+          }
+          return content;
+        } catch (err) {
+          markFileReadError(fileName, err);
+          log("error", `Error when reading file ${fileName}`, err);
+        }
+      }
+      break;
+    default: {
+      try {
+        return await readFileFs(fileName, { encoding: "utf8" });
+      } catch (err) {
+        log("error", `Error when reading file ${fileName}`, err);
+      }
+    }
+  }
 };
 
 /**
@@ -226,25 +226,25 @@ export const readFile = async function (fileName) {
  * @returns {Promise} gets resolved with the content of all docs, mocks, schema files
  */
 export const getFileContents = async function (sourceTree) {
-	const fileContents = {};
-	if (global.state) {
-		global.state.fileReadErrors = {};
-	}
-	const paths = await getFilePaths(sourceTree);
-
-	if (paths) {
-		await Promise.all(
-			paths.map(async (fullPath) => {
-				try {
-					fileContents[fullPath] = await readFile(fullPath.replace(/\0/g, ""));
-				} catch (err) {
-					return err;
-				}
-			}),
-		);
-
-		return fileContents;
-	}
-
-	return {};
+  const fileContents = {};
+  if (global.state) {
+    global.state.fileReadErrors = {};
+  }
+  const paths = await getFilePaths(sourceTree);
+
+  if (paths) {
+    await Promise.all(
+      paths.map(async (fullPath) => {
+        try {
+          fileContents[fullPath] = await readFile(fullPath.replace(/\0/g, ""));
+        } catch (err) {
+          return err;
+        }
+      }),
+    );
+
+    return fileContents;
+  }
+
+  return {};
 };

package/lib/state/helpers.js

@@ -18,55 +18,55 @@ import { EXIT_CODES, MiyagiError } from "../errors.js";
  * @returns {Promise<string[]>} an array with file paths
  */
 async function getFiles(dir, ignores, configPath, type, check) {
-	if (dir === null) return [];
+  if (dir === null) return [];
 
-	try {
-		var entries = await readdir(path.join(process.cwd(), dir), {
-			withFileTypes: true,
-		});
-	} catch (error) {
-		if (error.code === "ENOENT") {
-			const message = t("srcFolderNotFound")
-				.replaceAll("{{directory}}", dir)
-				.replaceAll("{{type}}", type)
-				.replaceAll("{{config}}", configPath);
-			log("error", message);
-			throw new MiyagiError(message, {
-				code: EXIT_CODES.CONFIG_ERROR,
-				logged: true,
-			});
-		} else {
-			log("error", error.toString(), error);
-			throw new MiyagiError(error.toString(), {
-				code: EXIT_CODES.GENERAL_ERROR,
-				logged: true,
-			});
-		}
-	}
+  try {
+    var entries = await readdir(path.join(process.cwd(), dir), {
+      withFileTypes: true,
+    });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      const message = t("srcFolderNotFound")
+        .replaceAll("{{directory}}", dir)
+        .replaceAll("{{type}}", type)
+        .replaceAll("{{config}}", configPath);
+      log("error", message);
+      throw new MiyagiError(message, {
+        code: EXIT_CODES.CONFIG_ERROR,
+        logged: true,
+      });
+    } else {
+      log("error", error.toString(), error);
+      throw new MiyagiError(error.toString(), {
+        code: EXIT_CODES.GENERAL_ERROR,
+        logged: true,
+      });
+    }
+  }
 
-	const files = await Promise.all(
-		entries.map(async (entry) => {
-			const res = path.resolve(dir, entry.name);
+  const files = await Promise.all(
+    entries.map(async (entry) => {
+      const res = path.resolve(dir, entry.name);
 
-			if (isNotIgnored(res, ignores)) {
-				if (entry.isDirectory() || entry.isSymbolicLink()) {
-					return await getFiles(
-						path.join(dir, entry.name),
-						ignores,
-						configPath,
-						type,
-						check,
-					);
-				} else {
-					return check(res);
-				}
-			} else {
-				return null;
-			}
-		}),
-	);
+      if (isNotIgnored(res, ignores)) {
+        if (entry.isDirectory() || entry.isSymbolicLink()) {
+          return await getFiles(
+            path.join(dir, entry.name),
+            ignores,
+            configPath,
+            type,
+            check,
+          );
+        } else {
+          return check(res);
+        }
+      } else {
+        return null;
+      }
+    }),
+  );
 
-	return Array.prototype.concat(...files).filter((file) => file !== null);
+  return Array.prototype.concat(...files).filter((file) => file !== null);
 }
 
 /**
@@ -76,16 +76,16 @@ async function getFiles(dir, ignores, configPath, type, check) {
  * @returns {boolean} returns true if the given file is not inside any of the given ignoredFolders
  */
 function isNotIgnored(file, ignoredFolders) {
-	for (let i = 0; i < ignoredFolders.length; i += 1) {
-		if (file.includes(ignoredFolders[i])) {
-			return false;
-		}
-	}
+  for (let i = 0; i < ignoredFolders.length; i += 1) {
+    if (file.includes(ignoredFolders[i])) {
+      return false;
+    }
+  }
 
-	return true;
+  return true;
 }
 
 export default {
-	getFiles,
-	isNotIgnored,
+  getFiles,
+  isNotIgnored,
 };

package/lib/state/index.js

@@ -15,43 +15,43 @@ import { getSourceTree } from "./source-tree.js";
  * @returns {Promise<object>}
  */
 export default async function setState(methods) {
-	if (!global.state) {
-		global.state = {
-			routes: [],
-			fileReadErrors: {},
-		};
-	}
-
-	if (methods.sourceTree) {
-		global.state.routes = [];
-		global.state.sourceTree = getSourceTree();
-	}
-
-	if (methods.fileContents) {
-		if (typeof methods.fileContents === "object") {
-			global.state.fileContents = methods.fileContents;
-		} else {
-			global.state.fileContents = await getFileContents(
-				global.state.sourceTree,
-			);
-		}
-	}
-
-	if (methods.partials) {
-		global.state.partials = getPartials(global.state.sourceTree);
-	}
-
-	if (methods.menu) {
-		global.state.menu = getMenu(global.state.sourceTree);
-		global.state.components = getComponents(
-			global.state.menu,
-			global.config.isBuild,
-		);
-	}
-
-	if (methods.css) {
-		global.state.css = getCSS(global.state.fileContents);
-	}
-
-	return global.state;
+  if (!global.state) {
+    global.state = {
+      routes: [],
+      fileReadErrors: {},
+    };
+  }
+
+  if (methods.sourceTree) {
+    global.state.routes = [];
+    global.state.sourceTree = getSourceTree();
+  }
+
+  if (methods.fileContents) {
+    if (typeof methods.fileContents === "object") {
+      global.state.fileContents = methods.fileContents;
+    } else {
+      global.state.fileContents = await getFileContents(
+        global.state.sourceTree,
+      );
+    }
+  }
+
+  if (methods.partials) {
+    global.state.partials = getPartials(global.state.sourceTree);
+  }
+
+  if (methods.menu) {
+    global.state.menu = getMenu(global.state.sourceTree);
+    global.state.components = getComponents(
+      global.state.menu,
+      global.config.isBuild,
+    );
+  }
+
+  if (methods.css) {
+    global.state.css = getCSS(global.state.fileContents);
+  }
+
+  return global.state;
 }