@schalkneethling/miyagi-core 4.4.2 → 4.4.3

package/lib/generator/component.js

@@ -12,21 +12,21 @@ import { t } from "../i18n/index.js";
  * @returns {Promise<string>}
  */
 export default async function componentGenerator({ component, fileTypes }) {
-	try {
-		await createComponentFolder(component);
-		await createComponentFiles(
-			global.config.files,
-			component,
-			fileTypes,
-			global.config.components.folder,
-		);
+  try {
+    await createComponentFolder(component);
+    await createComponentFiles(
+      global.config.files,
+      component,
+      fileTypes,
+      global.config.components.folder,
+    );
 
-		return Promise.resolve(
-			t("generator.component.done").replace("{{component}}", component),
-		);
-	} catch (err) {
-		return Promise.reject(err);
-	}
+    return Promise.resolve(
+      t("generator.component.done").replace("{{component}}", component),
+    );
+  } catch (err) {
+    return Promise.reject(err);
+  }
 }
 
 /**
@@ -36,7 +36,7 @@ export default async function componentGenerator({ component, fileTypes }) {
  * @returns {Array} all file paths that should be created
  */
 function getFiles(fileNames, fileTypes) {
-	return fileTypes.map((fileType) => fileNames[fileType]);
+  return fileTypes.map((fileType) => fileNames[fileType]);
 }
 
 /**
@@ -47,57 +47,57 @@ function getFiles(fileNames, fileTypes) {
  * @returns {string} dummy file content based on the given file type
  */
 function getDummyFileContent(fileType, filesConfig, componentPath) {
-	let str;
+  let str;
 
-	switch (fileType) {
-		case "mocks":
-			{
-				const data = {
-					$variants: [
-						{
-							$name: "",
-						},
-					],
-				};
+  switch (fileType) {
+    case "mocks":
+      {
+        const data = {
+          $variants: [
+            {
+              $name: "",
+            },
+          ],
+        };
 
-				if (["yaml", "yml"].includes(filesConfig.mocks.extension[0])) {
-					str = jsonToYaml.dump(data);
-				} else {
-					str = `${JSON.stringify(data, null, 2)}\n`;
-				}
-			}
-			break;
-		case "schema":
-			{
-				const id = path.join("/", componentPath);
+        if (["yaml", "yml"].includes(filesConfig.mocks.extension[0])) {
+          str = jsonToYaml.dump(data);
+        } else {
+          str = `${JSON.stringify(data, null, 2)}\n`;
+        }
+      }
+      break;
+    case "schema":
+      {
+        const id = path.join("/", componentPath);
 
-				if (["yaml", "yml"].includes(filesConfig.schema.extension)) {
-					str = `$schema: "http://json-schema.org/draft-07/schema"
+        if (["yaml", "yml"].includes(filesConfig.schema.extension)) {
+          str = `$schema: "http://json-schema.org/draft-07/schema"
 $id: "${id}"
 additionalProperties: false
 properties:
 required:
 `;
-				} else {
-					str = `${JSON.stringify(
-						{
-							$schema: "http://json-schema.org/draft-07/schema",
-							$id: id,
-							additionalProperties: false,
-							properties: {},
-							required: [],
-						},
-						null,
-						2,
-					)}\n`;
-				}
-			}
-			break;
-		default:
-			str = "";
-	}
+        } else {
+          str = `${JSON.stringify(
+            {
+              $schema: "http://json-schema.org/draft-07/schema",
+              $id: id,
+              additionalProperties: false,
+              properties: {},
+              required: [],
+            },
+            null,
+            2,
+          )}\n`;
+        }
+      }
+      break;
+    default:
+      str = "";
+  }
 
-	return str;
+  return str;
 }
 
 /**
@@ -109,39 +109,39 @@ required:
  * @returns {Promise} gets resolved when all files have been created
  */
 async function createComponentFiles(
-	filesConfig,
-	componentPath,
-	fileTypes,
-	componentFolder,
+  filesConfig,
+  componentPath,
+  fileTypes,
+  componentFolder,
 ) {
-	const componentName = path.basename(componentPath);
-	const fileNames = getFileNames(filesConfig, componentName);
-	const files = getFiles(fileNames, fileTypes);
-	const entries = Object.entries(fileNames);
+  const componentName = path.basename(componentPath);
+  const fileNames = getFileNames(filesConfig, componentName);
+  const files = getFiles(fileNames, fileTypes);
+  const entries = Object.entries(fileNames);
 
-	for (const [type, file] of entries) {
-		if (files.includes(file)) {
-			const fullFilePath = path.join(
-				process.env.INIT_CWD || process.cwd(),
-				componentPath,
-				file,
-			);
+  for (const [type, file] of entries) {
+    if (files.includes(file)) {
+      const fullFilePath = path.join(
+        process.env.INIT_CWD || process.cwd(),
+        componentPath,
+        file,
+      );
 
-			try {
-				await writeFile(
-					fullFilePath,
-					getDummyFileContent(
-						type,
-						filesConfig,
-						path.relative(componentFolder, componentPath),
-					),
-					{ flag: "wx" },
-				);
-			} catch (err) {
-				return Promise.reject(err.message);
-			}
-		}
-	}
+      try {
+        await writeFile(
+          fullFilePath,
+          getDummyFileContent(
+            type,
+            filesConfig,
+            path.relative(componentFolder, componentPath),
+          ),
+          { flag: "wx" },
+        );
+      } catch (err) {
+        return Promise.reject(err.message);
+      }
+    }
+  }
 }
 
 /**
@@ -151,21 +151,21 @@ async function createComponentFiles(
  * @returns {object} all file names based on the user configuration
  */
 function getFileNames(filesConfig, componentName) {
-	return {
-		tpl: `${helpers.getResolvedFileName(
-			filesConfig.templates.name,
-			componentName,
-		)}.${filesConfig.templates.extension}`,
-		mocks: `${filesConfig.mocks.name}.${filesConfig.mocks.extension[0]}`,
-		docs: "README.md",
-		css: `${helpers.getResolvedFileName(filesConfig.css.name, componentName)}.${
-			filesConfig.css.extension
-		}`,
-		js: `${helpers.getResolvedFileName(filesConfig.js.name, componentName)}.${
-			filesConfig.js.extension
-		}`,
-		schema: `${filesConfig.schema.name}.${filesConfig.schema.extension}`,
-	};
+  return {
+    tpl: `${helpers.getResolvedFileName(
+      filesConfig.templates.name,
+      componentName,
+    )}.${filesConfig.templates.extension}`,
+    mocks: `${filesConfig.mocks.name}.${filesConfig.mocks.extension[0]}`,
+    docs: "README.md",
+    css: `${helpers.getResolvedFileName(filesConfig.css.name, componentName)}.${
+      filesConfig.css.extension
+    }`,
+    js: `${helpers.getResolvedFileName(filesConfig.js.name, componentName)}.${
+      filesConfig.js.extension
+    }`,
+    schema: `${filesConfig.schema.name}.${filesConfig.schema.extension}`,
+  };
 }
 
 /**
@@ -174,26 +174,26 @@ function getFileNames(filesConfig, componentName) {
  * @returns {Promise} gets resolved when the folder has been created
  */
 async function createComponentFolder(folder) {
-	try {
-		await mkdir(
-			/*
-			 * When using `pnpm/yarn/npm miyagi new …`, `process.env.INIT_CWD` equals
-			 * the current working directory, so also subdirectories of where
-			 * the package.json is located. In this case `process.cwd()` always
-			 * equals the root directory though.
-			 * When using node directly, `process.env.INIT_CWD` is not available,
-			 * but `process.cwd()` is always the current working directory, so
-			 * also subdirectories.
-			 * So, if INIT_CWD is available, we know it is the directory the user
-			 * cd'ed into, if it not available, then we use process.cwd(), which
-			 * in that case is also the directory the user cd'ed into.
-			 * It is important that we let the user create a component from their
-			 * current working directory, so they can benefit from autocompletion.
-			 */
-			path.join(process.env.INIT_CWD || process.cwd(), folder),
-			{ recursive: true },
-		);
-	} catch (err) {
-		return err;
-	}
+  try {
+    await mkdir(
+      /*
+       * When using `pnpm/yarn/npm miyagi new …`, `process.env.INIT_CWD` equals
+       * the current working directory, so also subdirectories of where
+       * the package.json is located. In this case `process.cwd()` always
+       * equals the root directory though.
+       * When using node directly, `process.env.INIT_CWD` is not available,
+       * but `process.cwd()` is always the current working directory, so
+       * also subdirectories.
+       * So, if INIT_CWD is available, we know it is the directory the user
+       * cd'ed into, if it not available, then we use process.cwd(), which
+       * in that case is also the directory the user cd'ed into.
+       * It is important that we let the user create a component from their
+       * current working directory, so they can benefit from autocompletion.
+       */
+      path.join(process.env.INIT_CWD || process.cwd(), folder),
+      { recursive: true },
+    );
+  } catch (err) {
+    return err;
+  }
 }

package/lib/generator/mocks.js

@@ -13,112 +13,112 @@ import { t } from "../i18n/index.js";
  * @returns {Promise<{success, message?}>}
  */
 export default async function mockGenerator(folderPath, filesConfig) {
-	if (!folderPath) {
-		return {
-			success: false,
-			message: {
-				type: "error",
-				text: t("dataGenerator.noComponentFolderDefined"),
-			},
-		};
-	}
-
-	log("info", t("dataGenerator.starting").replace("{{fileName}}", folderPath));
-
-	const mockFilePath = `${path.join(folderPath, filesConfig.mocks.name)}.${
-		filesConfig.mocks.extension[0]
-	}`;
-	const schemaFilePath = `${path.join(folderPath, filesConfig.schema.name)}.${
-		filesConfig.schema.extension
-	}`;
-
-	const {
-		status,
-		data: schemaData,
-		message,
-	} = await readAndParseFile(schemaFilePath, filesConfig);
-
-	if (status === "success") {
-		try {
-			const content = getContent(filesConfig.mocks.extension[0], schemaData);
-
-			const { status, data } = await readAndParseFile(
-				mockFilePath,
-				filesConfig,
-			);
-
-			if (status === "success") {
-				if (data === "") {
-					const { status, message } = await createFile(content, mockFilePath);
-
-					if (status === "error") {
-						return {
-							success: false,
-							message: {
-								type: "error",
-								text: message,
-							},
-						};
-					} else {
-						return {
-							success: true,
-						};
-					}
-				} else {
-					return {
-						success: false,
-						message: {
-							type: "error",
-							text: t("dataGenerator.dataFileExists").replace(
-								"{{fileName}}",
-								mockFilePath,
-							),
-						},
-					};
-				}
-			} else {
-				const { status, message } = await createFile(content, mockFilePath);
-
-				if (status === "error") {
-					return {
-						success: false,
-						message: {
-							type: "error",
-							text: message,
-						},
-					};
-				} else {
-					return {
-						success: true,
-					};
-				}
-			}
-			// eslint-disable-next-line no-unused-vars
-		} catch (e) {
-			return {
-				success: false,
-				message: {
-					type: "error",
-					text: t("dataGenerator.schemaFileCantBeParsed").replace(
-						"{{fileName}}",
-						schemaFilePath,
-					),
-				},
-			};
-		}
-	} else {
-		return {
-			success: false,
-			message: {
-				type: "error",
-				text: t("dataGenerator.noSchemaFile").replace(
-					"{{fileName}}",
-					schemaFilePath,
-				),
-				verbose: message,
-			},
-		};
-	}
+  if (!folderPath) {
+    return {
+      success: false,
+      message: {
+        type: "error",
+        text: t("dataGenerator.noComponentFolderDefined"),
+      },
+    };
+  }
+
+  log("info", t("dataGenerator.starting").replace("{{fileName}}", folderPath));
+
+  const mockFilePath = `${path.join(folderPath, filesConfig.mocks.name)}.${
+    filesConfig.mocks.extension[0]
+  }`;
+  const schemaFilePath = `${path.join(folderPath, filesConfig.schema.name)}.${
+    filesConfig.schema.extension
+  }`;
+
+  const {
+    status,
+    data: schemaData,
+    message,
+  } = await readAndParseFile(schemaFilePath, filesConfig);
+
+  if (status === "success") {
+    try {
+      const content = getContent(filesConfig.mocks.extension[0], schemaData);
+
+      const { status, data } = await readAndParseFile(
+        mockFilePath,
+        filesConfig,
+      );
+
+      if (status === "success") {
+        if (data === "") {
+          const { status, message } = await createFile(content, mockFilePath);
+
+          if (status === "error") {
+            return {
+              success: false,
+              message: {
+                type: "error",
+                text: message,
+              },
+            };
+          } else {
+            return {
+              success: true,
+            };
+          }
+        } else {
+          return {
+            success: false,
+            message: {
+              type: "error",
+              text: t("dataGenerator.dataFileExists").replace(
+                "{{fileName}}",
+                mockFilePath,
+              ),
+            },
+          };
+        }
+      } else {
+        const { status, message } = await createFile(content, mockFilePath);
+
+        if (status === "error") {
+          return {
+            success: false,
+            message: {
+              type: "error",
+              text: message,
+            },
+          };
+        } else {
+          return {
+            success: true,
+          };
+        }
+      }
+      // eslint-disable-next-line no-unused-vars
+    } catch (e) {
+      return {
+        success: false,
+        message: {
+          type: "error",
+          text: t("dataGenerator.schemaFileCantBeParsed").replace(
+            "{{fileName}}",
+            schemaFilePath,
+          ),
+        },
+      };
+    }
+  } else {
+    return {
+      success: false,
+      message: {
+        type: "error",
+        text: t("dataGenerator.noSchemaFile").replace(
+          "{{fileName}}",
+          schemaFilePath,
+        ),
+        verbose: message,
+      },
+    };
+  }
 }
 
 /**
@@ -128,26 +128,26 @@ export default async function mockGenerator(folderPath, filesConfig) {
  * @returns {string} the dummy mock data
  */
 function getContent(fileType, schema) {
-	let content;
-	const data = schemaFaker.sample(schema);
-
-	switch (fileType) {
-		case "yaml":
-		case "yml":
-			content = jsYaml.dump(data);
-			break;
-		case "json":
-			content = JSON.stringify(data, null, 2);
-			break;
-		case "js":
-			content = `module.exports = ${JSON.stringify(data, null, 2)}
+  let content;
+  const data = schemaFaker.sample(schema);
+
+  switch (fileType) {
+    case "yaml":
+    case "yml":
+      content = jsYaml.dump(data);
+      break;
+    case "json":
+      content = JSON.stringify(data, null, 2);
+      break;
+    case "js":
+      content = `module.exports = ${JSON.stringify(data, null, 2)}
       `;
-			break;
-		default:
-			content = "";
-	}
+      break;
+    default:
+      content = "";
+  }
 
-	return content;
+  return content;
 }
 
 /**
@@ -157,18 +157,18 @@ function getContent(fileType, schema) {
  * @returns {Promise<object>}
  */
 async function createFile(content, mockFilePath) {
-	try {
-		await writeFile(mockFilePath, content);
-		return {
-			status: "success",
-			message: t("generator.done"),
-		};
-	} catch (err) {
-		return {
-			status: "error",
-			message: err.message,
-		};
-	}
+  try {
+    await writeFile(mockFilePath, content);
+    return {
+      status: "success",
+      message: t("generator.done"),
+    };
+  } catch (err) {
+    return {
+      status: "error",
+      message: err.message,
+    };
+  }
 }
 
 /**
@@ -178,24 +178,24 @@ async function createFile(content, mockFilePath) {
  * @returns {Promise<object>}
  */
 async function readAndParseFile(filePath, filesConfig) {
-	try {
-		const result = await readFile(filePath, "utf8");
-		let data;
-
-		if (["yaml", "yml"].includes(filesConfig.schema.extension)) {
-			data = jsYaml.load(result);
-		} else {
-			data = JSON.parse(result);
-		}
-
-		return {
-			status: "success",
-			data,
-		};
-	} catch (err) {
-		return {
-			status: "error",
-			message: err.message,
-		};
-	}
+  try {
+    const result = await readFile(filePath, "utf8");
+    let data;
+
+    if (["yaml", "yml"].includes(filesConfig.schema.extension)) {
+      data = jsYaml.load(result);
+    } else {
+      data = JSON.parse(result);
+    }
+
+    return {
+      status: "success",
+      data,
+    };
+  } catch (err) {
+    return {
+      status: "error",
+      message: err.message,
+    };
+  }
 }