gt 2.14.35 → 2.14.36

package/dist/formats/json/utils.js

@@ -1,203 +1,174 @@
-import { getLocaleProperties } from '@generaltranslation/format';
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { flattenJson } from './flattenJson.js';
-import chalk from 'chalk';
-import path from 'node:path';
-import micromatch from 'micromatch';
-import { getJSONPathMatches } from './jsonPath.js';
+import { logger } from "../../console/logger.js";
+import { exitSync } from "../../console/logging.js";
+import { getJSONPathMatches } from "./jsonPath.js";
+import { flattenJson } from "./flattenJson.js";
+import chalk from "chalk";
+import path from "node:path";
+import micromatch from "micromatch";
+import { getLocaleProperties } from "@generaltranslation/format";
+//#region src/formats/json/utils.ts
 const { isMatch } = micromatch;
-// Find the matching source item in an array
-// where the key matches the identifying locale property
-// If no matching item is found, exit with an error
-export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue) {
-    const { identifyingLocaleProperty, localeKeyJsonPath } = getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions);
-    // Use the json pointer key to locate the source item
-    const matchingItems = {};
-    for (const [index, item] of sourceObjectValue.entries()) {
-        // Get the key candidates
-        const keyCandidates = getJSONPathMatches(item, localeKeyJsonPath);
-        if (!keyCandidates) {
-            logger.error(`Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`);
-            return exitSync(1);
-        }
-        else if (keyCandidates.length === 0) {
-            // If no key candidates, skip the item
-            continue;
-        }
-        else if (keyCandidates.length > 1) {
-            // If multiple key candidates, exit with an error
-            logger.error(`Source item at path: ${sourceObjectPointer} has multiple matching keys with path: ${localeKeyJsonPath}`);
-            return exitSync(1);
-        }
-        else if (identifyingLocaleProperty !== keyCandidates[0].value) {
-            // Validate the key is the identifying locale property
-            continue;
-        }
-        const keyParentProperty = keyCandidates[0].parentProperty;
-        if (keyParentProperty === null) {
-            logger.error(`Source item at path: ${sourceObjectPointer} has a root-level key match with path: ${localeKeyJsonPath}`);
-            return exitSync(1);
-        }
-        // Map the index to the source item
-        matchingItems[`/${index}`] = {
-            sourceItem: item,
-            keyParentProperty,
-            keyPointer: keyCandidates[0].pointer,
-            index,
-        };
-    }
-    return matchingItems;
+function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue) {
+	const { identifyingLocaleProperty, localeKeyJsonPath } = getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions);
+	const matchingItems = {};
+	for (const [index, item] of sourceObjectValue.entries()) {
+		const keyCandidates = getJSONPathMatches(item, localeKeyJsonPath);
+		if (!keyCandidates) {
+			logger.error(`Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`);
+			return exitSync(1);
+		} else if (keyCandidates.length === 0) continue;
+		else if (keyCandidates.length > 1) {
+			logger.error(`Source item at path: ${sourceObjectPointer} has multiple matching keys with path: ${localeKeyJsonPath}`);
+			return exitSync(1);
+		} else if (identifyingLocaleProperty !== keyCandidates[0].value) continue;
+		const keyParentProperty = keyCandidates[0].parentProperty;
+		if (keyParentProperty === null) {
+			logger.error(`Source item at path: ${sourceObjectPointer} has a root-level key match with path: ${localeKeyJsonPath}`);
+			return exitSync(1);
+		}
+		matchingItems[`/${index}`] = {
+			sourceItem: item,
+			keyParentProperty,
+			keyPointer: keyCandidates[0].pointer,
+			index
+		};
+	}
+	return matchingItems;
 }
-export function findMatchingItemObject(locale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue) {
-    const { identifyingLocaleProperty } = getSourceObjectOptionsObject(locale, sourceObjectPointer, sourceObjectOptions);
-    // Locate the source item
-    if (sourceObjectValue[identifyingLocaleProperty]) {
-        return {
-            sourceItem: sourceObjectValue[identifyingLocaleProperty],
-            keyParentProperty: identifyingLocaleProperty,
-        };
-    }
-    return {
-        sourceItem: undefined,
-        keyParentProperty: identifyingLocaleProperty,
-    };
+function findMatchingItemObject(locale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue) {
+	const { identifyingLocaleProperty } = getSourceObjectOptionsObject(locale, sourceObjectPointer, sourceObjectOptions);
+	if (sourceObjectValue[identifyingLocaleProperty]) return {
+		sourceItem: sourceObjectValue[identifyingLocaleProperty],
+		keyParentProperty: identifyingLocaleProperty
+	};
+	return {
+		sourceItem: void 0,
+		keyParentProperty: identifyingLocaleProperty
+	};
 }
 /**
- * Get the identifying locale property for an object
- * @param locale - The locale to get the identifying locale property for
- * @param sourceObjectPointer - The path to the source object
- * @param sourceObjectOptions - The source object options
- * @returns The identifying locale property
- */
-export function getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions) {
-    // Validate localeProperty
-    const localeProperty = sourceObjectOptions.localeProperty || 'code';
-    const identifyingLocaleProperty = getLocaleProperties(locale)[localeProperty];
-    if (!identifyingLocaleProperty) {
-        logger.error(`Source object options localeProperty is not a valid locale property at path: ${sourceObjectPointer}`);
-        return exitSync(1);
-    }
-    return identifyingLocaleProperty;
+* Get the identifying locale property for an object
+* @param locale - The locale to get the identifying locale property for
+* @param sourceObjectPointer - The path to the source object
+* @param sourceObjectOptions - The source object options
+* @returns The identifying locale property
+*/
+function getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions) {
+	const localeProperty = sourceObjectOptions.localeProperty || "code";
+	const identifyingLocaleProperty = getLocaleProperties(locale)[localeProperty];
+	if (!identifyingLocaleProperty) {
+		logger.error(`Source object options localeProperty is not a valid locale property at path: ${sourceObjectPointer}`);
+		return exitSync(1);
+	}
+	return identifyingLocaleProperty;
 }
 /**
- * Get the identifying locale property and the json path to the key for an array
- * @param locale - The locale to get the identifying locale property for
- * @param sourceObjectPointer - The path to the source object
- * @param sourceObjectOptions - The source object options
- * @returns The identifying locale property and the json path to the key
- */
-export function getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions);
-    const localeKeyJsonPath = sourceObjectOptions.key;
-    if (!localeKeyJsonPath) {
-        logger.error(`Source object options key is required for array at path: ${sourceObjectPointer}`);
-        return exitSync(1);
-    }
-    return { identifyingLocaleProperty, localeKeyJsonPath };
+* Get the identifying locale property and the json path to the key for an array
+* @param locale - The locale to get the identifying locale property for
+* @param sourceObjectPointer - The path to the source object
+* @param sourceObjectOptions - The source object options
+* @returns The identifying locale property and the json path to the key
+*/
+function getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions) {
+	const identifyingLocaleProperty = getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions);
+	const localeKeyJsonPath = sourceObjectOptions.key;
+	if (!localeKeyJsonPath) {
+		logger.error(`Source object options key is required for array at path: ${sourceObjectPointer}`);
+		return exitSync(1);
+	}
+	return {
+		identifyingLocaleProperty,
+		localeKeyJsonPath
+	};
 }
-export function getSourceObjectOptionsObject(defaultLocale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
-    const jsonPathKey = sourceObjectOptions.key;
-    if (jsonPathKey) {
-        logger.error(`Source object options key is not allowed for object at path: ${sourceObjectPointer}`);
-        return exitSync(1);
-    }
-    return { identifyingLocaleProperty };
+function getSourceObjectOptionsObject(defaultLocale, sourceObjectPointer, sourceObjectOptions) {
+	const identifyingLocaleProperty = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
+	if (sourceObjectOptions.key) {
+		logger.error(`Source object options key is not allowed for object at path: ${sourceObjectPointer}`);
+		return exitSync(1);
+	}
+	return { identifyingLocaleProperty };
 }
 /**
- * Generate a mapping of sourceObjectPointer to SourceObjectOptions
- * where the sourceObjectPointer is a jsonpointer to the array or object containing
- * @param jsonSchema - The json schema to generate the mapping from
- * @param originalJson - The original json to generate the mapping from
- * @returns A mapping of sourceObjectPointer to SourceObjectOptions
- */
-export function generateSourceObjectPointers(jsonSchema, originalJson) {
-    const sourceObjectPointers = Object.entries(jsonSchema).reduce((acc, [sourceObjectPath, sourceObjectOptions]) => {
-        const sourceObjects = flattenJson(originalJson, [sourceObjectPath]);
-        Object.entries(sourceObjects).forEach(([pointer, value]) => {
-            acc[pointer] = {
-                sourceObjectValue: value,
-                sourceObjectOptions,
-            };
-        });
-        return acc;
-    }, {});
-    return sourceObjectPointers;
+* Generate a mapping of sourceObjectPointer to SourceObjectOptions
+* where the sourceObjectPointer is a jsonpointer to the array or object containing
+* @param jsonSchema - The json schema to generate the mapping from
+* @param originalJson - The original json to generate the mapping from
+* @returns A mapping of sourceObjectPointer to SourceObjectOptions
+*/
+function generateSourceObjectPointers(jsonSchema, originalJson) {
+	return Object.entries(jsonSchema).reduce((acc, [sourceObjectPath, sourceObjectOptions]) => {
+		const sourceObjects = flattenJson(originalJson, [sourceObjectPath]);
+		Object.entries(sourceObjects).forEach(([pointer, value]) => {
+			acc[pointer] = {
+				sourceObjectValue: value,
+				sourceObjectOptions
+			};
+		});
+		return acc;
+	}, {});
 }
 /**
- * Validate the json schema for composite or include schemas
- * @param options - Additional options containing jsonSchema config
- * @param filePath - The path to the file (used for matching jsonSchema)
- * @returns The json schema, or null if no schema is found
- * @returns exitSync(1) if the json schema is invalid
- */
-export function validateJsonSchema(options, filePath) {
-    if (!options.jsonSchema) {
-        return null;
-    }
-    const fileGlobs = Object.keys(options.jsonSchema);
-    const matchingGlob = fileGlobs.find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
-    if (!matchingGlob || !options.jsonSchema[matchingGlob]) {
-        return null;
-    }
-    // Validate includes or composite
-    const jsonSchema = options.jsonSchema[matchingGlob];
-    if (jsonSchema.include && jsonSchema.composite) {
-        logger.error('include and composite cannot be used together in the same JSON schema');
-        return exitSync(1);
-    }
-    if (!jsonSchema.include && !jsonSchema.composite) {
-        logger.error('No include or composite property found in JSON schema');
-        return exitSync(1);
-    }
-    if (jsonSchema.structuralTransform && !jsonSchema.composite) {
-        logger.error('structuralTransform requires composite to be defined in the JSON schema');
-        return exitSync(1);
-    }
-    return jsonSchema;
+* Validate the json schema for composite or include schemas
+* @param options - Additional options containing jsonSchema config
+* @param filePath - The path to the file (used for matching jsonSchema)
+* @returns The json schema, or null if no schema is found
+* @returns exitSync(1) if the json schema is invalid
+*/
+function validateJsonSchema(options, filePath) {
+	if (!options.jsonSchema) return null;
+	const matchingGlob = Object.keys(options.jsonSchema).find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
+	if (!matchingGlob || !options.jsonSchema[matchingGlob]) return null;
+	const jsonSchema = options.jsonSchema[matchingGlob];
+	if (jsonSchema.include && jsonSchema.composite) {
+		logger.error("include and composite cannot be used together in the same JSON schema");
+		return exitSync(1);
+	}
+	if (!jsonSchema.include && !jsonSchema.composite) {
+		logger.error("No include or composite property found in JSON schema");
+		return exitSync(1);
+	}
+	if (jsonSchema.structuralTransform && !jsonSchema.composite) {
+		logger.error("structuralTransform requires composite to be defined in the JSON schema");
+		return exitSync(1);
+	}
+	return jsonSchema;
 }
-const UNSUPPORTED_MINTLIFY_FIELDS = ['$ref'];
+const UNSUPPORTED_MINTLIFY_FIELDS = ["$ref"];
 /**
- * Recursively traverse a JSON value and collect all objects whose key
- * matches one of the unsupported field names.
- */
-function findMintlifyUnsupportedFields(value, fieldNames, pointer = '') {
-    if (value === null || typeof value !== 'object')
-        return [];
-    if (Array.isArray(value)) {
-        const results = [];
-        for (let i = 0; i < value.length; i++) {
-            results.push(...findMintlifyUnsupportedFields(value[i], fieldNames, `${pointer}/${i}`));
-        }
-        return results;
-    }
-    // Check if this object contains an unsupported field
-    const objectValue = value;
-    for (const field of fieldNames) {
-        if (typeof objectValue[field] === 'string') {
-            return [{ pointer, field, fieldValue: objectValue[field] }];
-        }
-    }
-    // Recurse into child properties
-    const results = [];
-    for (const key of Object.keys(objectValue)) {
-        results.push(...findMintlifyUnsupportedFields(objectValue[key], fieldNames, `${pointer}/${key}`));
-    }
-    return results;
+* Recursively traverse a JSON value and collect all objects whose key
+* matches one of the unsupported field names.
+*/
+function findMintlifyUnsupportedFields(value, fieldNames, pointer = "") {
+	if (value === null || typeof value !== "object") return [];
+	if (Array.isArray(value)) {
+		const results = [];
+		for (let i = 0; i < value.length; i++) results.push(...findMintlifyUnsupportedFields(value[i], fieldNames, `${pointer}/${i}`));
+		return results;
+	}
+	const objectValue = value;
+	for (const field of fieldNames) if (typeof objectValue[field] === "string") return [{
+		pointer,
+		field,
+		fieldValue: objectValue[field]
+	}];
+	const results = [];
+	for (const key of Object.keys(objectValue)) results.push(...findMintlifyUnsupportedFields(objectValue[key], fieldNames, `${pointer}/${key}`));
+	return results;
 }
 /**
- * Detect unsupported fields (e.g. $ref) in Mintlify docs.json files.
- * Logs a warning listing the fields found.
- */
-export function detectMintlifyUnsupportedFields(json, filePath) {
-    const unsupported = findMintlifyUnsupportedFields(json, UNSUPPORTED_MINTLIFY_FIELDS);
-    if (unsupported.length > 0) {
-        const fileName = path.basename(filePath);
-        const lines = unsupported
-            .map((u) => chalk.yellow('• ') +
-            chalk.white(`${u.pointer.replace(/\//g, '.').replace(/^\./, '')}.${u.field}`))
-            .join('\n');
-        logger.warn(chalk.yellow(`Mintlify config splitting is not yet supported. The following \`$ref\` fields were detected in \`${fileName}\` and will not be resolved:\n`) + lines);
-    }
+* Detect unsupported fields (e.g. $ref) in Mintlify docs.json files.
+* Logs a warning listing the fields found.
+*/
+function detectMintlifyUnsupportedFields(json, filePath) {
+	const unsupported = findMintlifyUnsupportedFields(json, UNSUPPORTED_MINTLIFY_FIELDS);
+	if (unsupported.length > 0) {
+		const fileName = path.basename(filePath);
+		const lines = unsupported.map((u) => chalk.yellow("• ") + chalk.white(`${u.pointer.replace(/\//g, ".").replace(/^\./, "")}.${u.field}`)).join("\n");
+		logger.warn(chalk.yellow(`Mintlify config splitting is not yet supported. The following \`$ref\` fields were detected in \`${fileName}\` and will not be resolved:\n`) + lines);
+	}
 }
+//#endregion
+export { detectMintlifyUnsupportedFields, findMatchingItemArray, findMatchingItemObject, generateSourceObjectPointers, getIdentifyingLocaleProperty, getSourceObjectOptionsArray, getSourceObjectOptionsObject, validateJsonSchema };
+
+//# sourceMappingURL=utils.js.map

package/dist/formats/json/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/formats/json/utils.ts"],"sourcesContent":["import { getLocaleProperties } from '@generaltranslation/format';\nimport { exitSync } from '../../console/logging.js';\nimport { logger } from '../../console/logger.js';\nimport type { LocaleProperties } from '@generaltranslation/format/types';\nimport {\n  AdditionalOptions,\n  JsonSchema,\n  SourceObjectOptions,\n} from '../../types/index.js';\nimport { flattenJson } from './flattenJson.js';\nimport chalk from 'chalk';\nimport path from 'node:path';\nimport micromatch from 'micromatch';\nimport type { JSONObject, JSONValue } from '../../types/data/json.js';\nimport { getJSONPathMatches } from './jsonPath.js';\nconst { isMatch } = micromatch;\n\ntype MatchingArrayItem = {\n  sourceItem: JSONValue;\n  keyParentProperty: string | number;\n  keyPointer: string;\n  index: number;\n};\n\ntype SourceObjectPointerMap = Record<\n  string,\n  { sourceObjectValue: JSONValue; sourceObjectOptions: SourceObjectOptions }\n>;\n\n// Find the matching source item in an array\n// where the key matches the identifying locale property\n// If no matching item is found, exit with an error\nexport function findMatchingItemArray(\n  locale: string,\n  sourceObjectOptions: SourceObjectOptions,\n  sourceObjectPointer: string,\n  sourceObjectValue: JSONValue[]\n): Record<string, MatchingArrayItem> {\n  const { identifyingLocaleProperty, localeKeyJsonPath } =\n    getSourceObjectOptionsArray(\n      locale,\n      sourceObjectPointer,\n      sourceObjectOptions\n    );\n  // Use the json pointer key to locate the source item\n  const matchingItems: Record<string, MatchingArrayItem> = {};\n  for (const [index, item] of sourceObjectValue.entries()) {\n    // Get the key candidates\n    const keyCandidates = getJSONPathMatches(item, localeKeyJsonPath);\n    if (!keyCandidates) {\n      logger.error(\n        `Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`\n      );\n      return exitSync(1);\n    } else if (keyCandidates.length === 0) {\n      // If no key candidates, skip the item\n      continue;\n    } else if (keyCandidates.length > 1) {\n      // If multiple key candidates, exit with an error\n      logger.error(\n        `Source item at path: ${sourceObjectPointer} has multiple matching keys with path: ${localeKeyJsonPath}`\n      );\n      return exitSync(1);\n    } else if (identifyingLocaleProperty !== keyCandidates[0].value) {\n      // Validate the key is the identifying locale property\n      continue;\n    }\n    const keyParentProperty = keyCandidates[0].parentProperty;\n    if (keyParentProperty === null) {\n      logger.error(\n        `Source item at path: ${sourceObjectPointer} has a root-level key match with path: ${localeKeyJsonPath}`\n      );\n      return exitSync(1);\n    }\n    // Map the index to the source item\n    matchingItems[`/${index}`] = {\n      sourceItem: item,\n      keyParentProperty,\n      keyPointer: keyCandidates[0].pointer,\n      index,\n    };\n  }\n  return matchingItems;\n}\n\nexport function findMatchingItemObject(\n  locale: string,\n  sourceObjectPointer: string,\n  sourceObjectOptions: SourceObjectOptions,\n  sourceObjectValue: JSONObject\n): { sourceItem: JSONValue | undefined; keyParentProperty: string } {\n  const { identifyingLocaleProperty } = getSourceObjectOptionsObject(\n    locale,\n    sourceObjectPointer,\n    sourceObjectOptions\n  );\n\n  // Locate the source item\n  if (sourceObjectValue[identifyingLocaleProperty]) {\n    return {\n      sourceItem: sourceObjectValue[identifyingLocaleProperty],\n      keyParentProperty: identifyingLocaleProperty,\n    };\n  }\n  return {\n    sourceItem: undefined,\n    keyParentProperty: identifyingLocaleProperty,\n  };\n}\n\n/**\n * Get the identifying locale property for an object\n * @param locale - The locale to get the identifying locale property for\n * @param sourceObjectPointer - The path to the source object\n * @param sourceObjectOptions - The source object options\n * @returns The identifying locale property\n */\nexport function getIdentifyingLocaleProperty(\n  locale: string,\n  sourceObjectPointer: string,\n  sourceObjectOptions: SourceObjectOptions\n): string {\n  // Validate localeProperty\n  const localeProperty = sourceObjectOptions.localeProperty || 'code';\n  const identifyingLocaleProperty =\n    getLocaleProperties(locale)[localeProperty as keyof LocaleProperties];\n  if (!identifyingLocaleProperty) {\n    logger.error(\n      `Source object options localeProperty is not a valid locale property at path: ${sourceObjectPointer}`\n    );\n    return exitSync(1);\n  }\n  return identifyingLocaleProperty;\n}\n\n/**\n * Get the identifying locale property and the json path to the key for an array\n * @param locale - The locale to get the identifying locale property for\n * @param sourceObjectPointer - The path to the source object\n * @param sourceObjectOptions - The source object options\n * @returns The identifying locale property and the json path to the key\n */\nexport function getSourceObjectOptionsArray(\n  locale: string,\n  sourceObjectPointer: string,\n  sourceObjectOptions: SourceObjectOptions\n): { identifyingLocaleProperty: string; localeKeyJsonPath: string } {\n  const identifyingLocaleProperty = getIdentifyingLocaleProperty(\n    locale,\n    sourceObjectPointer,\n    sourceObjectOptions\n  );\n  const localeKeyJsonPath = sourceObjectOptions.key;\n  if (!localeKeyJsonPath) {\n    logger.error(\n      `Source object options key is required for array at path: ${sourceObjectPointer}`\n    );\n    return exitSync(1);\n  }\n  return { identifyingLocaleProperty, localeKeyJsonPath };\n}\n\nexport function getSourceObjectOptionsObject(\n  defaultLocale: string,\n  sourceObjectPointer: string,\n  sourceObjectOptions: SourceObjectOptions\n): { identifyingLocaleProperty: string } {\n  const identifyingLocaleProperty = getIdentifyingLocaleProperty(\n    defaultLocale,\n    sourceObjectPointer,\n    sourceObjectOptions\n  );\n  const jsonPathKey = sourceObjectOptions.key;\n  if (jsonPathKey) {\n    logger.error(\n      `Source object options key is not allowed for object at path: ${sourceObjectPointer}`\n    );\n    return exitSync(1);\n  }\n  return { identifyingLocaleProperty };\n}\n\n/**\n * Generate a mapping of sourceObjectPointer to SourceObjectOptions\n * where the sourceObjectPointer is a jsonpointer to the array or object containing\n * @param jsonSchema - The json schema to generate the mapping from\n * @param originalJson - The original json to generate the mapping from\n * @returns A mapping of sourceObjectPointer to SourceObjectOptions\n */\nexport function generateSourceObjectPointers(\n  jsonSchema: {\n    [sourceObjectPath: string]: SourceObjectOptions;\n  },\n  originalJson: JSONValue\n): SourceObjectPointerMap {\n  const sourceObjectPointers = Object.entries(jsonSchema).reduce(\n    (acc: SourceObjectPointerMap, [sourceObjectPath, sourceObjectOptions]) => {\n      const sourceObjects = flattenJson(originalJson, [sourceObjectPath]);\n      Object.entries(sourceObjects).forEach(([pointer, value]) => {\n        acc[pointer as string] = {\n          sourceObjectValue: value,\n          sourceObjectOptions,\n        };\n      });\n      return acc;\n    },\n    {}\n  );\n  return sourceObjectPointers;\n}\n\n/**\n * Validate the json schema for composite or include schemas\n * @param options - Additional options containing jsonSchema config\n * @param filePath - The path to the file (used for matching jsonSchema)\n * @returns The json schema, or null if no schema is found\n * @returns exitSync(1) if the json schema is invalid\n */\nexport function validateJsonSchema(\n  options: AdditionalOptions,\n  filePath: string\n): JsonSchema | null {\n  if (!options.jsonSchema) {\n    return null;\n  }\n\n  const fileGlobs = Object.keys(options.jsonSchema);\n  const matchingGlob = fileGlobs.find((fileGlob) =>\n    isMatch(path.relative(process.cwd(), filePath), fileGlob)\n  );\n  if (!matchingGlob || !options.jsonSchema[matchingGlob]) {\n    return null;\n  }\n  // Validate includes or composite\n  const jsonSchema = options.jsonSchema[matchingGlob];\n  if (jsonSchema.include && jsonSchema.composite) {\n    logger.error(\n      'include and composite cannot be used together in the same JSON schema'\n    );\n    return exitSync(1);\n  }\n\n  if (!jsonSchema.include && !jsonSchema.composite) {\n    logger.error('No include or composite property found in JSON schema');\n    return exitSync(1);\n  }\n\n  if (jsonSchema.structuralTransform && !jsonSchema.composite) {\n    logger.error(\n      'structuralTransform requires composite to be defined in the JSON schema'\n    );\n    return exitSync(1);\n  }\n  return jsonSchema;\n}\n\nconst UNSUPPORTED_MINTLIFY_FIELDS = ['$ref'];\n\n/**\n * Recursively traverse a JSON value and collect all objects whose key\n * matches one of the unsupported field names.\n */\nfunction findMintlifyUnsupportedFields(\n  value: JSONValue,\n  fieldNames: string[],\n  pointer: string = ''\n): { pointer: string; field: string; fieldValue: string }[] {\n  if (value === null || typeof value !== 'object') return [];\n  if (Array.isArray(value)) {\n    const results: { pointer: string; field: string; fieldValue: string }[] =\n      [];\n    for (let i = 0; i < value.length; i++) {\n      results.push(\n        ...findMintlifyUnsupportedFields(\n          value[i],\n          fieldNames,\n          `${pointer}/${i}`\n        )\n      );\n    }\n    return results;\n  }\n  // Check if this object contains an unsupported field\n  const objectValue = value as JSONObject;\n  for (const field of fieldNames) {\n    if (typeof objectValue[field] === 'string') {\n      return [{ pointer, field, fieldValue: objectValue[field] }];\n    }\n  }\n  // Recurse into child properties\n  const results: { pointer: string; field: string; fieldValue: string }[] = [];\n  for (const key of Object.keys(objectValue)) {\n    results.push(\n      ...findMintlifyUnsupportedFields(\n        objectValue[key],\n        fieldNames,\n        `${pointer}/${key}`\n      )\n    );\n  }\n  return results;\n}\n\n/**\n * Detect unsupported fields (e.g. $ref) in Mintlify docs.json files.\n * Logs a warning listing the fields found.\n */\nexport function detectMintlifyUnsupportedFields(\n  json: JSONValue,\n  filePath: string\n): void {\n  const unsupported = findMintlifyUnsupportedFields(\n    json,\n    UNSUPPORTED_MINTLIFY_FIELDS\n  );\n\n  if (unsupported.length > 0) {\n    const fileName = path.basename(filePath);\n    const lines = unsupported\n      .map(\n        (u) =>\n          chalk.yellow('• ') +\n          chalk.white(\n            `${u.pointer.replace(/\\//g, '.').replace(/^\\./, '')}.${u.field}`\n          )\n      )\n      .join('\\n');\n    logger.warn(\n      chalk.yellow(\n        `Mintlify config splitting is not yet supported. The following \\`$ref\\` fields were detected in \\`${fileName}\\` and will not be resolved:\\n`\n      ) + lines\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/formats/parseKeyedMetadata.js

@@ -1,111 +1,90 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import YAML from 'yaml';
-import { logger } from '../console/logger.js';
-import { exitSync } from '../console/logging.js';
+import { logger } from "../console/logger.js";
+import { exitSync } from "../console/logging.js";
+import path from "node:path";
+import fs from "node:fs";
+import YAML from "yaml";
+//#region src/formats/parseKeyedMetadata.ts
 /**
- * Validates that the metadata key structure is a subset of the source key structure.
- * Uses the source to determine whether a metadata value is a leaf (source value is a string)
- * or a nested object (source value is an object).
- */
+* Validates that the metadata key structure is a subset of the source key structure.
+* Uses the source to determine whether a metadata value is a leaf (source value is a string)
+* or a nested object (source value is an object).
+*/
 function validateMetadataStructure(source, metadata, currentPath = []) {
-    const errors = [];
-    for (const key of Object.keys(metadata)) {
-        const sourceValue = source[key];
-        const keyPath = [...currentPath, key];
-        if (sourceValue === undefined) {
-            errors.push(`Key "${keyPath.join('.')}" does not exist in source`);
-            continue;
-        }
-        // If the source value is a string, this is a translatable leaf — metadata should be a MetadataLeaf
-        // If the source value is a nested object, recurse
-        if (typeof sourceValue === 'object' &&
-            sourceValue !== null &&
-            !Array.isArray(sourceValue)) {
-            const metaValue = metadata[key];
-            if (Array.isArray(metaValue)) {
-                errors.push(`Key "${keyPath.join('.')}" is an array but source is an object`);
-            }
-            else if (typeof metaValue === 'object' && metaValue !== null) {
-                errors.push(...validateMetadataStructure(sourceValue, metaValue, keyPath));
-            }
-            else {
-                errors.push(`Key "${keyPath.join('.')}" is a primitive but source is an object`);
-            }
-        }
-    }
-    return errors;
+	const errors = [];
+	for (const key of Object.keys(metadata)) {
+		const sourceValue = source[key];
+		const keyPath = [...currentPath, key];
+		if (sourceValue === void 0) {
+			errors.push(`Key "${keyPath.join(".")}" does not exist in source`);
+			continue;
+		}
+		if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue)) {
+			const metaValue = metadata[key];
+			if (Array.isArray(metaValue)) errors.push(`Key "${keyPath.join(".")}" is an array but source is an object`);
+			else if (typeof metaValue === "object" && metaValue !== null) errors.push(...validateMetadataStructure(sourceValue, metaValue, keyPath));
+			else errors.push(`Key "${keyPath.join(".")}" is a primitive but source is an object`);
+		}
+	}
+	return errors;
 }
 /**
- * Detects and parses a companion metadata file for a given source file.
- *
- * For `translations.json`, looks for `translations.metadata.json`.
- * For `translations.yaml` or `translations.yml`, looks for `translations.metadata.yaml` or `.yml`.
- *
- * @param sourceFilePath - Absolute path to the source file
- * @param sourceContent - Parsed source content (object) for structure validation
- * @returns Parsed metadata object, or undefined if no companion file exists
- */
-export function parseKeyedMetadata(sourceFilePath, sourceContent) {
-    const ext = path.extname(sourceFilePath);
-    const baseName = sourceFilePath.slice(0, -ext.length);
-    // Determine companion file path and parser
-    let metadataFilePath;
-    let parse;
-    if (ext === '.json') {
-        metadataFilePath = `${baseName}.metadata.json`;
-        parse = JSON.parse;
-    }
-    else if (ext === '.yaml' || ext === '.yml') {
-        const yamlPath = `${baseName}.metadata.yaml`;
-        const ymlPath = `${baseName}.metadata.yml`;
-        if (fs.existsSync(yamlPath)) {
-            metadataFilePath = yamlPath;
-        }
-        else if (fs.existsSync(ymlPath)) {
-            metadataFilePath = ymlPath;
-        }
-        parse = YAML.parse;
-    }
-    if (!metadataFilePath || !parse) {
-        return undefined;
-    }
-    if (!fs.existsSync(metadataFilePath)) {
-        return undefined;
-    }
-    // Read and parse
-    let metadataContent;
-    try {
-        const raw = fs.readFileSync(metadataFilePath, 'utf8');
-        const parsed = parse(raw);
-        if (typeof parsed !== 'object' || parsed === null) {
-            const relativePath = path.relative(process.cwd(), metadataFilePath);
-            logger.error(`Metadata file ${relativePath}: Expected an object or array`);
-            return exitSync(1);
-        }
-        metadataContent = parsed;
-    }
-    catch {
-        const relativePath = path.relative(process.cwd(), metadataFilePath);
-        logger.error(`Metadata file ${relativePath}: File is not parsable`);
-        return exitSync(1);
-    }
-    // Reject if root types don't match (array vs object)
-    if (Array.isArray(metadataContent) !== Array.isArray(sourceContent)) {
-        const relativePath = path.relative(process.cwd(), metadataFilePath);
-        logger.error(`Metadata file ${relativePath}: Root type (array vs object) does not match source`);
-        return exitSync(1);
-    }
-    // Validate structure against source (only for object-rooted files)
-    if (!Array.isArray(metadataContent) && !Array.isArray(sourceContent)) {
-        const errors = validateMetadataStructure(sourceContent, metadataContent);
-        if (errors.length > 0) {
-            const relativePath = path.relative(process.cwd(), metadataFilePath);
-            for (const error of errors) {
-                logger.error(`Metadata file ${relativePath}: ${error}`);
-            }
-            return exitSync(1);
-        }
-    }
-    return metadataContent;
+* Detects and parses a companion metadata file for a given source file.
+*
+* For `translations.json`, looks for `translations.metadata.json`.
+* For `translations.yaml` or `translations.yml`, looks for `translations.metadata.yaml` or `.yml`.
+*
+* @param sourceFilePath - Absolute path to the source file
+* @param sourceContent - Parsed source content (object) for structure validation
+* @returns Parsed metadata object, or undefined if no companion file exists
+*/
+function parseKeyedMetadata(sourceFilePath, sourceContent) {
+	const ext = path.extname(sourceFilePath);
+	const baseName = sourceFilePath.slice(0, -ext.length);
+	let metadataFilePath;
+	let parse;
+	if (ext === ".json") {
+		metadataFilePath = `${baseName}.metadata.json`;
+		parse = JSON.parse;
+	} else if (ext === ".yaml" || ext === ".yml") {
+		const yamlPath = `${baseName}.metadata.yaml`;
+		const ymlPath = `${baseName}.metadata.yml`;
+		if (fs.existsSync(yamlPath)) metadataFilePath = yamlPath;
+		else if (fs.existsSync(ymlPath)) metadataFilePath = ymlPath;
+		parse = YAML.parse;
+	}
+	if (!metadataFilePath || !parse) return;
+	if (!fs.existsSync(metadataFilePath)) return;
+	let metadataContent;
+	try {
+		const raw = fs.readFileSync(metadataFilePath, "utf8");
+		const parsed = parse(raw);
+		if (typeof parsed !== "object" || parsed === null) {
+			const relativePath = path.relative(process.cwd(), metadataFilePath);
+			logger.error(`Metadata file ${relativePath}: Expected an object or array`);
+			return exitSync(1);
+		}
+		metadataContent = parsed;
+	} catch {
+		const relativePath = path.relative(process.cwd(), metadataFilePath);
+		logger.error(`Metadata file ${relativePath}: File is not parsable`);
+		return exitSync(1);
+	}
+	if (Array.isArray(metadataContent) !== Array.isArray(sourceContent)) {
+		const relativePath = path.relative(process.cwd(), metadataFilePath);
+		logger.error(`Metadata file ${relativePath}: Root type (array vs object) does not match source`);
+		return exitSync(1);
+	}
+	if (!Array.isArray(metadataContent) && !Array.isArray(sourceContent)) {
+		const errors = validateMetadataStructure(sourceContent, metadataContent);
+		if (errors.length > 0) {
+			const relativePath = path.relative(process.cwd(), metadataFilePath);
+			for (const error of errors) logger.error(`Metadata file ${relativePath}: ${error}`);
+			return exitSync(1);
+		}
+	}
+	return metadataContent;
 }
+//#endregion
+export { parseKeyedMetadata };
+
+//# sourceMappingURL=parseKeyedMetadata.js.map

package/dist/formats/parseKeyedMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseKeyedMetadata.js","names":[],"sources":["../../src/formats/parseKeyedMetadata.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport YAML from 'yaml';\nimport { logger } from '../console/logger.js';\nimport { exitSync } from '../console/logging.js';\nimport type { SourceCode } from '../react/jsx/utils/extractSourceCode.js';\nimport type { JSONObject } from '../types/data/json.js';\n\nexport type MetadataLeaf = {\n  context?: string;\n  maxChars?: number;\n  sourceCode?: Record<string, SourceCode[]>;\n};\n\nexport type MetadataObject = { [key: string]: MetadataLeaf | MetadataObject };\nexport type MetadataArray = (MetadataLeaf | MetadataObject)[];\nexport type KeyedMetadata = MetadataObject | MetadataArray;\n\n/**\n * Validates that the metadata key structure is a subset of the source key structure.\n * Uses the source to determine whether a metadata value is a leaf (source value is a string)\n * or a nested object (source value is an object).\n */\nfunction validateMetadataStructure(\n  source: JSONObject,\n  metadata: MetadataObject,\n  currentPath: string[] = []\n): string[] {\n  const errors: string[] = [];\n\n  for (const key of Object.keys(metadata)) {\n    const sourceValue = source[key];\n    const keyPath = [...currentPath, key];\n\n    if (sourceValue === undefined) {\n      errors.push(`Key \"${keyPath.join('.')}\" does not exist in source`);\n      continue;\n    }\n\n    // If the source value is a string, this is a translatable leaf — metadata should be a MetadataLeaf\n    // If the source value is a nested object, recurse\n    if (\n      typeof sourceValue === 'object' &&\n      sourceValue !== null &&\n      !Array.isArray(sourceValue)\n    ) {\n      const metaValue = metadata[key];\n      if (Array.isArray(metaValue)) {\n        errors.push(\n          `Key \"${keyPath.join('.')}\" is an array but source is an object`\n        );\n      } else if (typeof metaValue === 'object' && metaValue !== null) {\n        errors.push(\n          ...validateMetadataStructure(\n            sourceValue as JSONObject,\n            metaValue as MetadataObject,\n            keyPath\n          )\n        );\n      } else {\n        errors.push(\n          `Key \"${keyPath.join('.')}\" is a primitive but source is an object`\n        );\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Detects and parses a companion metadata file for a given source file.\n *\n * For `translations.json`, looks for `translations.metadata.json`.\n * For `translations.yaml` or `translations.yml`, looks for `translations.metadata.yaml` or `.yml`.\n *\n * @param sourceFilePath - Absolute path to the source file\n * @param sourceContent - Parsed source content (object) for structure validation\n * @returns Parsed metadata object, or undefined if no companion file exists\n */\nexport function parseKeyedMetadata(\n  sourceFilePath: string,\n  sourceContent: JSONObject | JSONObject[]\n): KeyedMetadata | undefined {\n  const ext = path.extname(sourceFilePath);\n  const baseName = sourceFilePath.slice(0, -ext.length);\n\n  // Determine companion file path and parser\n  let metadataFilePath: string | undefined;\n  let parse: ((content: string) => JSONObject) | undefined;\n\n  if (ext === '.json') {\n    metadataFilePath = `${baseName}.metadata.json`;\n    parse = JSON.parse;\n  } else if (ext === '.yaml' || ext === '.yml') {\n    const yamlPath = `${baseName}.metadata.yaml`;\n    const ymlPath = `${baseName}.metadata.yml`;\n    if (fs.existsSync(yamlPath)) {\n      metadataFilePath = yamlPath;\n    } else if (fs.existsSync(ymlPath)) {\n      metadataFilePath = ymlPath;\n    }\n    parse = YAML.parse;\n  }\n\n  if (!metadataFilePath || !parse) {\n    return undefined;\n  }\n\n  if (!fs.existsSync(metadataFilePath)) {\n    return undefined;\n  }\n\n  // Read and parse\n  let metadataContent: KeyedMetadata;\n  try {\n    const raw = fs.readFileSync(metadataFilePath, 'utf8');\n    const parsed = parse(raw);\n    if (typeof parsed !== 'object' || parsed === null) {\n      const relativePath = path.relative(process.cwd(), metadataFilePath);\n      logger.error(\n        `Metadata file ${relativePath}: Expected an object or array`\n      );\n      return exitSync(1);\n    }\n    metadataContent = parsed as KeyedMetadata;\n  } catch {\n    const relativePath = path.relative(process.cwd(), metadataFilePath);\n    logger.error(`Metadata file ${relativePath}: File is not parsable`);\n    return exitSync(1);\n  }\n\n  // Reject if root types don't match (array vs object)\n  if (Array.isArray(metadataContent) !== Array.isArray(sourceContent)) {\n    const relativePath = path.relative(process.cwd(), metadataFilePath);\n    logger.error(\n      `Metadata file ${relativePath}: Root type (array vs object) does not match source`\n    );\n    return exitSync(1);\n  }\n\n  // Validate structure against source (only for object-rooted files)\n  if (!Array.isArray(metadataContent) && !Array.isArray(sourceContent)) {\n    const errors = validateMetadataStructure(sourceContent, metadataContent);\n    if (errors.length > 0) {\n      const relativePath = path.relative(process.cwd(), metadataFilePath);\n      for (const error of errors) {\n        logger.error(`Metadata file ${relativePath}: ${error}`);\n      }\n      return exitSync(1);\n    }\n  }\n\n  return metadataContent;\n}\n"],"mappings":";;;;;;;;;;;AAuBA,SAAS,0BACP,QACA,UACA,cAAwB,EAAE,EAChB;CACV,MAAM,SAAmB,EAAE;AAE3B,MAAK,MAAM,OAAO,OAAO,KAAK,SAAS,EAAE;EACvC,MAAM,cAAc,OAAO;EAC3B,MAAM,UAAU,CAAC,GAAG,aAAa,IAAI;AAErC,MAAI,gBAAgB,KAAA,GAAW;AAC7B,UAAO,KAAK,QAAQ,QAAQ,KAAK,IAAI,CAAC,4BAA4B;AAClE;;AAKF,MACE,OAAO,gBAAgB,YACvB,gBAAgB,QAChB,CAAC,MAAM,QAAQ,YAAY,EAC3B;GACA,MAAM,YAAY,SAAS;AAC3B,OAAI,MAAM,QAAQ,UAAU,CAC1B,QAAO,KACL,QAAQ,QAAQ,KAAK,IAAI,CAAC,uCAC3B;YACQ,OAAO,cAAc,YAAY,cAAc,KACxD,QAAO,KACL,GAAG,0BACD,aACA,WACA,QACD,CACF;OAED,QAAO,KACL,QAAQ,QAAQ,KAAK,IAAI,CAAC,0CAC3B;;;AAKP,QAAO;;;;;;;;;;;;AAaT,SAAgB,mBACd,gBACA,eAC2B;CAC3B,MAAM,MAAM,KAAK,QAAQ,eAAe;CACxC,MAAM,WAAW,eAAe,MAAM,GAAG,CAAC,IAAI,OAAO;CAGrD,IAAI;CACJ,IAAI;AAEJ,KAAI,QAAQ,SAAS;AACnB,qBAAmB,GAAG,SAAS;AAC/B,UAAQ,KAAK;YACJ,QAAQ,WAAW,QAAQ,QAAQ;EAC5C,MAAM,WAAW,GAAG,SAAS;EAC7B,MAAM,UAAU,GAAG,SAAS;AAC5B,MAAI,GAAG,WAAW,SAAS,CACzB,oBAAmB;WACV,GAAG,WAAW,QAAQ,CAC/B,oBAAmB;AAErB,UAAQ,KAAK;;AAGf,KAAI,CAAC,oBAAoB,CAAC,MACxB;AAGF,KAAI,CAAC,GAAG,WAAW,iBAAiB,CAClC;CAIF,IAAI;AACJ,KAAI;EACF,MAAM,MAAM,GAAG,aAAa,kBAAkB,OAAO;EACrD,MAAM,SAAS,MAAM,IAAI;AACzB,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;GACjD,MAAM,eAAe,KAAK,SAAS,QAAQ,KAAK,EAAE,iBAAiB;AACnE,UAAO,MACL,iBAAiB,aAAa,+BAC/B;AACD,UAAO,SAAS,EAAE;;AAEpB,oBAAkB;SACZ;EACN,MAAM,eAAe,KAAK,SAAS,QAAQ,KAAK,EAAE,iBAAiB;AACnE,SAAO,MAAM,iBAAiB,aAAa,wBAAwB;AACnE,SAAO,SAAS,EAAE;;AAIpB,KAAI,MAAM,QAAQ,gBAAgB,KAAK,MAAM,QAAQ,cAAc,EAAE;EACnE,MAAM,eAAe,KAAK,SAAS,QAAQ,KAAK,EAAE,iBAAiB;AACnE,SAAO,MACL,iBAAiB,aAAa,qDAC/B;AACD,SAAO,SAAS,EAAE;;AAIpB,KAAI,CAAC,MAAM,QAAQ,gBAAgB,IAAI,CAAC,MAAM,QAAQ,cAAc,EAAE;EACpE,MAAM,SAAS,0BAA0B,eAAe,gBAAgB;AACxE,MAAI,OAAO,SAAS,GAAG;GACrB,MAAM,eAAe,KAAK,SAAS,QAAQ,KAAK,EAAE,iBAAiB;AACnE,QAAK,MAAM,SAAS,OAClB,QAAO,MAAM,iBAAiB,aAAa,IAAI,QAAQ;AAEzD,UAAO,SAAS,EAAE;;;AAItB,QAAO"}