@schalkneethling/miyagi-core 4.4.2 → 4.4.4

package/lib/mocks/resolve/ref.js

@@ -11,133 +11,133 @@ import { mergeRootDataWithVariationData } from "../resolve.js";
  * @returns {Promise<object|Array|string|boolean>} the resolved value from the mock data object
  */
 export const resolveRefs = async function (entry, component) {
-	const messages = [];
-
-	if (entry) {
-		if (
-			typeof entry === "string" ||
-			typeof entry === "number" ||
-			typeof entry === "boolean" ||
-			entry instanceof Map ||
-			entry === null
-		) {
-			return {
-				messages,
-				data: entry,
-			};
-		}
-
-		if (entry instanceof Array) {
-			const o = [];
-
-			for (const ent of entry) {
-				let newComponent = component;
-
-				if (ent.$ref) {
-					if (!ent.$ref.startsWith("#/$defs/")) {
-						if (ent.$ref.startsWith("/")) {
-							ent.$ref = ent.$ref.replace("/", "");
-						}
-						const path = ent.$ref.split("#")[0];
-						const { resolved, message } = resolveNamespace(path);
-
-						if (resolved) {
-							newComponent = global.state.routes.find(
-								(route) => route.paths.dir.short === resolved,
-							);
-						} else {
-							messages.push(message);
-						}
-					}
-				}
-
-				const json = await resolve(ent, newComponent);
-				const result = await resolveRefs(json.data, newComponent);
-
-				o.push(result.data);
-
-				for (const msg of [...json.messages, ...result.messages]) {
-					if (msg) {
-						messages.push(msg);
-					}
-				}
-			}
-
-			return {
-				messages,
-				data: o,
-			};
-		}
-
-		let o = entry;
-
-		for (const [key, value] of Object.entries({ ...entry })) {
-			if (key === "$ref") {
-				let newComponent;
-
-				if (value.startsWith("#/$defs/")) {
-					newComponent = component;
-				} else {
-					let path = value.split("#")[0];
-
-					if (path.startsWith("/")) {
-						path = path.replace("/", "");
-					}
-
-					const { resolved, message } = resolveNamespace(path);
-
-					if (resolved) {
-						newComponent = global.state.routes.find(
-							(route) => route.paths.dir.short === resolved,
-						);
-					} else {
-						messages.push(message);
-					}
-				}
-
-				let { message, data: resolvedValue } =
-					await getRootOrVariantDataOfReference(value, newComponent);
-
-				if (message) {
-					messages.push(message);
-				}
-
-				const json = await resolve(resolvedValue, newComponent);
-				const result = await resolveRefs(json.data, newComponent);
-
-				for (const msg of [...json.messages, ...result.messages]) {
-					if (msg) {
-						messages.push(msg);
-					}
-				}
-
-				o = { ...o, ...result.data };
-
-				delete o.$ref;
-			} else {
-				const json = await resolve(value, component);
-				const result = await resolveRefs(json.data, component);
-
-				o[key] = result.data;
-
-				for (const msg of [...json.messages, ...result.messages]) {
-					if (msg) {
-						messages.push(msg);
-					}
-				}
-			}
-		}
-
-		return {
-			messages,
-			data: o,
-		};
-	}
-
-	return {
-		messages,
-		data: entry,
-	};
+  const messages = [];
+
+  if (entry) {
+    if (
+      typeof entry === "string" ||
+      typeof entry === "number" ||
+      typeof entry === "boolean" ||
+      entry instanceof Map ||
+      entry === null
+    ) {
+      return {
+        messages,
+        data: entry,
+      };
+    }
+
+    if (entry instanceof Array) {
+      const o = [];
+
+      for (const ent of entry) {
+        let newComponent = component;
+
+        if (ent.$ref) {
+          if (!ent.$ref.startsWith("#/$defs/")) {
+            if (ent.$ref.startsWith("/")) {
+              ent.$ref = ent.$ref.replace("/", "");
+            }
+            const path = ent.$ref.split("#")[0];
+            const { resolved, message } = resolveNamespace(path);
+
+            if (resolved) {
+              newComponent = global.state.routes.find(
+                (route) => route.paths.dir.short === resolved,
+              );
+            } else {
+              messages.push(message);
+            }
+          }
+        }
+
+        const json = await resolve(ent, newComponent);
+        const result = await resolveRefs(json.data, newComponent);
+
+        o.push(result.data);
+
+        for (const msg of [...json.messages, ...result.messages]) {
+          if (msg) {
+            messages.push(msg);
+          }
+        }
+      }
+
+      return {
+        messages,
+        data: o,
+      };
+    }
+
+    let o = entry;
+
+    for (const [key, value] of Object.entries({ ...entry })) {
+      if (key === "$ref") {
+        let newComponent;
+
+        if (value.startsWith("#/$defs/")) {
+          newComponent = component;
+        } else {
+          let path = value.split("#")[0];
+
+          if (path.startsWith("/")) {
+            path = path.replace("/", "");
+          }
+
+          const { resolved, message } = resolveNamespace(path);
+
+          if (resolved) {
+            newComponent = global.state.routes.find(
+              (route) => route.paths.dir.short === resolved,
+            );
+          } else {
+            messages.push(message);
+          }
+        }
+
+        let { message, data: resolvedValue } =
+          await getRootOrVariantDataOfReference(value, newComponent);
+
+        if (message) {
+          messages.push(message);
+        }
+
+        const json = await resolve(resolvedValue, newComponent);
+        const result = await resolveRefs(json.data, newComponent);
+
+        for (const msg of [...json.messages, ...result.messages]) {
+          if (msg) {
+            messages.push(msg);
+          }
+        }
+
+        o = { ...o, ...result.data };
+
+        delete o.$ref;
+      } else {
+        const json = await resolve(value, component);
+        const result = await resolveRefs(json.data, component);
+
+        o[key] = result.data;
+
+        for (const msg of [...json.messages, ...result.messages]) {
+          if (msg) {
+            messages.push(msg);
+          }
+        }
+      }
+    }
+
+    return {
+      messages,
+      data: o,
+    };
+  }
+
+  return {
+    messages,
+    data: entry,
+  };
 };
 
 /**
@@ -146,98 +146,98 @@ export const resolveRefs = async function (entry, component) {
  * @returns {Promise<object|Array|string|boolean>} the resolved value from the mock data object
  */
 async function resolve(entry, component) {
-	const messages = [];
-
-	if (entry !== null) {
-		if (Array.isArray(entry)) {
-			return {
-				messages,
-				data: entry,
-			};
-		}
-
-		if (
-			typeof entry === "string" ||
-			typeof entry === "number" ||
-			typeof entry === "boolean" ||
-			entry instanceof Map ||
-			entry === null
-		) {
-			return {
-				messages,
-				data: entry,
-			};
-		}
-
-		if (entry === undefined) {
-			return {
-				messages: [
-					...messages,
-					{
-						type: "warn",
-						text: t("referencedMockFileNotFound"),
-					},
-				],
-				data: entry,
-			};
-		}
-
-		if (entry.$ref) {
-			const customData = helpers.cloneDeep(entry);
-			delete customData.$ref;
-
-			let newComponent;
-
-			if (entry.$ref.startsWith("#/$defs/")) {
-				newComponent = component;
-			} else {
-				let path = entry.$ref.split("#")[0];
-
-				if (path.startsWith("/")) {
-					path = path.replace("/", "");
-				}
-
-				const { resolved, message } = resolveNamespace(path);
-
-				if (resolved) {
-					newComponent = global.state.routes.find(
-						(route) => route.paths.dir.short === resolved,
-					);
-
-					if (!newComponent) {
-						messages.push({
-							type: "warn",
-							text: `${resolved} not found`,
-						});
-					}
-				} else {
-					messages.push(message);
-				}
-			}
-
-			if (newComponent) {
-				const { message, data } = await getRootOrVariantDataOfReference(
-					entry.$ref,
-					newComponent,
-				);
-
-				return {
-					messages: [...messages, message],
-					data: deepMerge(data, customData),
-				};
-			} else {
-				return {
-					messages,
-					data: customData,
-				};
-			}
-		}
-	}
-
-	return {
-		messages,
-		data: entry,
-	};
+  const messages = [];
+
+  if (entry !== null) {
+    if (Array.isArray(entry)) {
+      return {
+        messages,
+        data: entry,
+      };
+    }
+
+    if (
+      typeof entry === "string" ||
+      typeof entry === "number" ||
+      typeof entry === "boolean" ||
+      entry instanceof Map ||
+      entry === null
+    ) {
+      return {
+        messages,
+        data: entry,
+      };
+    }
+
+    if (entry === undefined) {
+      return {
+        messages: [
+          ...messages,
+          {
+            type: "warn",
+            text: t("referencedMockFileNotFound"),
+          },
+        ],
+        data: entry,
+      };
+    }
+
+    if (entry.$ref) {
+      const customData = helpers.cloneDeep(entry);
+      delete customData.$ref;
+
+      let newComponent;
+
+      if (entry.$ref.startsWith("#/$defs/")) {
+        newComponent = component;
+      } else {
+        let path = entry.$ref.split("#")[0];
+
+        if (path.startsWith("/")) {
+          path = path.replace("/", "");
+        }
+
+        const { resolved, message } = resolveNamespace(path);
+
+        if (resolved) {
+          newComponent = global.state.routes.find(
+            (route) => route.paths.dir.short === resolved,
+          );
+
+          if (!newComponent) {
+            messages.push({
+              type: "warn",
+              text: `${resolved} not found`,
+            });
+          }
+        } else {
+          messages.push(message);
+        }
+      }
+
+      if (newComponent) {
+        const { message, data } = await getRootOrVariantDataOfReference(
+          entry.$ref,
+          newComponent,
+        );
+
+        return {
+          messages: [...messages, message],
+          data: deepMerge(data, customData),
+        };
+      } else {
+        return {
+          messages,
+          data: customData,
+        };
+      }
+    }
+  }
+
+  return {
+    messages,
+    data: entry,
+  };
 }
 
 /**
@@ -246,203 +246,203 @@ async function resolve(entry, component) {
  * @returns {Promise<object>} the resolved data object
  */
 async function getRootOrVariantDataOfReference(ref, component) {
-	const { mocks } = global.config.files;
-
-	let [shortVal, variation] = ref.split("#");
-	let jsonFromData;
-	let mocksBaseName;
-	let fullPath;
-
-	if (ref.startsWith("#/$defs/")) {
-		const componentJson = helpers.cloneDeep(
-			global.state.fileContents[
-				component.paths.mocks.full(global.config.files.mocks.extension[0])
-			] ||
-				global.state.fileContents[
-					component.paths.mocks.full(global.config.files.mocks.extension[1])
-				],
-		);
-
-		mocksBaseName = ref;
-
-		const defRef = ref.replace("#/$defs/", "");
-		if ("$defs" in componentJson && defRef in componentJson.$defs) {
-			return {
-				data: componentJson.$defs[defRef],
-			};
-		}
-
-		return {
-			message: {
-				type: "warn",
-				text: t("fileNotFoundLinkIncorrect")
-					.replace("{{filePath}}", mocksBaseName)
-					.replace(
-						"{{component}}",
-						component.paths.mocks.short(
-							global.config.files.mocks.extension[0],
-						) ||
-							component.paths.mocks.short(
-								global.config.files.mocks.extension[1],
-							),
-					),
-			},
-			data: {},
-		};
-	}
-
-	if (ref.startsWith(`${global.config.files.mocks.name}/#/$defs/`)) {
-		const defaultFile = helpers.getFullPathFromShortPath(
-			`${global.config.files.mocks.name}.${global.config.files.mocks.extension[0]}`,
-		);
-		const jsFile = helpers.getFullPathFromShortPath(
-			`${global.config.files.mocks.name}.${global.config.files.mocks.extension[1]}`,
-		);
-		const globalData = {
-			...(global.state.fileContents[defaultFile] ||
-				global.state.fileContents[jsFile]),
-		};
-
-		const defRef = ref.replace(
-			`${global.config.files.mocks.name}/#/$defs/`,
-			"",
-		);
-
-		if (defRef in globalData.$defs) {
-			return {
-				data: globalData.$defs[defRef],
-			};
-		}
-
-		return {
-			message: {
-				type: "warn",
-				text: t("fileNotFoundLinkIncorrect")
-					.replace("{{filePath}}", ref)
-					.replace(
-						"{{component}}",
-						component.paths.mocks.short(
-							global.config.files.mocks.extension[0],
-						) ||
-							component.paths.mocks.short(
-								global.config.files.mocks.extension[1],
-							),
-					),
-			},
-			data: {},
-		};
-	}
-
-	if (shortVal.startsWith("@")) {
-		const namespace = shortVal.split("/")[0];
-		const resolvedNamespace = global.config.namespaces[namespace];
-
-		if (!resolvedNamespace) {
-			return {
-				message: {
-					type: "warn",
-					text: `Could not resolve namespace ${namespace}`,
-				},
-				data: null,
-			};
-		}
-
-		shortVal = path.relative(namespace, shortVal);
-		mocksBaseName = path.join(shortVal, mocks.name);
-		fullPath = path.join(
-			process.cwd(),
-			resolvedNamespace,
-			shortVal,
-			mocks.name,
-		);
-	} else {
-		mocksBaseName = path.join(shortVal, mocks.name);
-		fullPath = helpers.getFullPathFromShortPath(mocksBaseName);
-	}
-
-	jsonFromData =
-		global.state.fileContents[`${fullPath}.${mocks.extension[0]}`] ||
-		global.state.fileContents[`${fullPath}.${mocks.extension[1]}`];
-
-	if (jsonFromData) {
-		if (variation?.startsWith("/$defs/") && "$defs" in jsonFromData) {
-			const defRef = variation.replace("/$defs/", "");
-
-			if (defRef in jsonFromData.$defs) {
-				return {
-					data: jsonFromData.$defs[defRef],
-				};
-			}
-
-			return {
-				message: {
-					type: "warn",
-					text: t("fileNotFoundLinkIncorrect")
-						.replace("{{filePath}}", ref)
-						.replace(
-							"{{component}}",
-							component.paths.mocks.short(
-								global.config.files.mocks.extension[0],
-							) ||
-								component.paths.mocks.short(
-									global.config.files.mocks.extension[1],
-								),
-						),
-				},
-				data: {},
-			};
-		}
-
-		const embeddedJson = jsonFromData;
-		const rootJson = helpers.removeInternalKeys(embeddedJson);
-		let variantJson = {};
-		let message;
-
-		if (variation && embeddedJson.$variants && embeddedJson.$variants.length) {
-			const variant = embeddedJson.$variants.find((vari) => {
-				if (vari.$name) {
-					return (
-						helpers.normalizeString(vari.$name) ===
-						helpers.normalizeString(variation)
-					);
-				}
-				return false;
-			});
-
-			if (variant) {
-				variantJson = helpers.removeInternalKeys(variant);
-			} else {
-				message = {
-					type: "warn",
-					text: t("variationNotFound")
-						.replace("{{variation}}", variation)
-						.replace("{{fileName}}", mocksBaseName),
-				};
-			}
-		}
-
-		return {
-			message,
-			data: mergeRootDataWithVariationData(
-				helpers.cloneDeep(rootJson),
-				variantJson,
-			),
-		};
-	}
-
-	return {
-		message: {
-			type: "warn",
-			text: t("fileNotFoundLinkIncorrect")
-				.replace("{{filePath}}", mocksBaseName)
-				.replace(
-					"{{component}}",
-					component.paths.mocks.short(global.config.files.mocks.extension[0]) ||
-						component.paths.mocks.short(global.config.files.mocks.extension[1]),
-				),
-		},
-		data: {},
-	};
+  const { mocks } = global.config.files;
+
+  let [shortVal, variation] = ref.split("#");
+  let jsonFromData;
+  let mocksBaseName;
+  let fullPath;
+
+  if (ref.startsWith("#/$defs/")) {
+    const componentJson = helpers.cloneDeep(
+      global.state.fileContents[
+        component.paths.mocks.full(global.config.files.mocks.extension[0])
+      ] ||
+        global.state.fileContents[
+          component.paths.mocks.full(global.config.files.mocks.extension[1])
+        ],
+    );
+
+    mocksBaseName = ref;
+
+    const defRef = ref.replace("#/$defs/", "");
+    if ("$defs" in componentJson && defRef in componentJson.$defs) {
+      return {
+        data: componentJson.$defs[defRef],
+      };
+    }
+
+    return {
+      message: {
+        type: "warn",
+        text: t("fileNotFoundLinkIncorrect")
+          .replace("{{filePath}}", mocksBaseName)
+          .replace(
+            "{{component}}",
+            component.paths.mocks.short(
+              global.config.files.mocks.extension[0],
+            ) ||
+              component.paths.mocks.short(
+                global.config.files.mocks.extension[1],
+              ),
+          ),
+      },
+      data: {},
+    };
+  }
+
+  if (ref.startsWith(`${global.config.files.mocks.name}/#/$defs/`)) {
+    const defaultFile = helpers.getFullPathFromShortPath(
+      `${global.config.files.mocks.name}.${global.config.files.mocks.extension[0]}`,
+    );
+    const jsFile = helpers.getFullPathFromShortPath(
+      `${global.config.files.mocks.name}.${global.config.files.mocks.extension[1]}`,
+    );
+    const globalData = {
+      ...(global.state.fileContents[defaultFile] ||
+        global.state.fileContents[jsFile]),
+    };
+
+    const defRef = ref.replace(
+      `${global.config.files.mocks.name}/#/$defs/`,
+      "",
+    );
+
+    if (defRef in globalData.$defs) {
+      return {
+        data: globalData.$defs[defRef],
+      };
+    }
+
+    return {
+      message: {
+        type: "warn",
+        text: t("fileNotFoundLinkIncorrect")
+          .replace("{{filePath}}", ref)
+          .replace(
+            "{{component}}",
+            component.paths.mocks.short(
+              global.config.files.mocks.extension[0],
+            ) ||
+              component.paths.mocks.short(
+                global.config.files.mocks.extension[1],
+              ),
+          ),
+      },
+      data: {},
+    };
+  }
+
+  if (shortVal.startsWith("@")) {
+    const namespace = shortVal.split("/")[0];
+    const resolvedNamespace = global.config.namespaces[namespace];
+
+    if (!resolvedNamespace) {
+      return {
+        message: {
+          type: "warn",
+          text: `Could not resolve namespace ${namespace}`,
+        },
+        data: null,
+      };
+    }
+
+    shortVal = path.relative(namespace, shortVal);
+    mocksBaseName = path.join(shortVal, mocks.name);
+    fullPath = path.join(
+      process.cwd(),
+      resolvedNamespace,
+      shortVal,
+      mocks.name,
+    );
+  } else {
+    mocksBaseName = path.join(shortVal, mocks.name);
+    fullPath = helpers.getFullPathFromShortPath(mocksBaseName);
+  }
+
+  jsonFromData =
+    global.state.fileContents[`${fullPath}.${mocks.extension[0]}`] ||
+    global.state.fileContents[`${fullPath}.${mocks.extension[1]}`];
+
+  if (jsonFromData) {
+    if (variation?.startsWith("/$defs/") && "$defs" in jsonFromData) {
+      const defRef = variation.replace("/$defs/", "");
+
+      if (defRef in jsonFromData.$defs) {
+        return {
+          data: jsonFromData.$defs[defRef],
+        };
+      }
+
+      return {
+        message: {
+          type: "warn",
+          text: t("fileNotFoundLinkIncorrect")
+            .replace("{{filePath}}", ref)
+            .replace(
+              "{{component}}",
+              component.paths.mocks.short(
+                global.config.files.mocks.extension[0],
+              ) ||
+                component.paths.mocks.short(
+                  global.config.files.mocks.extension[1],
+                ),
+            ),
+        },
+        data: {},
+      };
+    }
+
+    const embeddedJson = jsonFromData;
+    const rootJson = helpers.removeInternalKeys(embeddedJson);
+    let variantJson = {};
+    let message;
+
+    if (variation && embeddedJson.$variants && embeddedJson.$variants.length) {
+      const variant = embeddedJson.$variants.find((vari) => {
+        if (vari.$name) {
+          return (
+            helpers.normalizeString(vari.$name) ===
+            helpers.normalizeString(variation)
+          );
+        }
+        return false;
+      });
+
+      if (variant) {
+        variantJson = helpers.removeInternalKeys(variant);
+      } else {
+        message = {
+          type: "warn",
+          text: t("variationNotFound")
+            .replace("{{variation}}", variation)
+            .replace("{{fileName}}", mocksBaseName),
+        };
+      }
+    }
+
+    return {
+      message,
+      data: mergeRootDataWithVariationData(
+        helpers.cloneDeep(rootJson),
+        variantJson,
+      ),
+    };
+  }
+
+  return {
+    message: {
+      type: "warn",
+      text: t("fileNotFoundLinkIncorrect")
+        .replace("{{filePath}}", mocksBaseName)
+        .replace(
+          "{{component}}",
+          component.paths.mocks.short(global.config.files.mocks.extension[0]) ||
+            component.paths.mocks.short(global.config.files.mocks.extension[1]),
+        ),
+    },
+    data: {},
+  };
 }
 
 /**
@@ -450,35 +450,35 @@ async function getRootOrVariantDataOfReference(ref, component) {
  * @returns {object}
  */
 function resolveNamespace(namespacedPath) {
-	if (
-		!Object.keys(global.config.namespaces).some((namespace) =>
-			namespacedPath.startsWith(namespace),
-		)
-	) {
-		return {
-			resolved: namespacedPath,
-		};
-	}
-
-	const namespace = namespacedPath.split("/")[0];
-	const resolvedNamespace = global.config.namespaces[namespace];
-
-	if (!resolvedNamespace) {
-		return {
-			message: {
-				type: "warn",
-				text: `Could not resolve namespace ${namespace}`,
-			},
-			resolved: null,
-		};
-	}
-
-	return {
-		resolved: namespacedPath.replace(
-			namespace,
-			helpers.getShortPathFromFullPath(
-				path.join(process.cwd(), resolvedNamespace),
-			),
-		),
-	};
+  if (
+    !Object.keys(global.config.namespaces).some((namespace) =>
+      namespacedPath.startsWith(namespace),
+    )
+  ) {
+    return {
+      resolved: namespacedPath,
+    };
+  }
+
+  const namespace = namespacedPath.split("/")[0];
+  const resolvedNamespace = global.config.namespaces[namespace];
+
+  if (!resolvedNamespace) {
+    return {
+      message: {
+        type: "warn",
+        text: `Could not resolve namespace ${namespace}`,
+      },
+      resolved: null,
+    };
+  }
+
+  return {
+    resolved: namespacedPath.replace(
+      namespace,
+      helpers.getShortPathFromFullPath(
+        path.join(process.cwd(), resolvedNamespace),
+      ),
+    ),
+  };
 }