@intlayer/chokidar/dist/esm/writeContentDeclaration/writeContentDeclaration.mjs

Uses chokidar to scan and build Intlayer declaration files into dictionaries based on Intlayer configuration.

import configuration from "@intlayer/config/built";
import dictionariesRecord from "@intlayer/unmerged-dictionaries-entry";
import deepEqual from "deep-equal";
import { existsSync } from "fs";
import { mkdir, writeFile } from "fs/promises";
import { dirname, extname } from "path";
import { prepareContentDeclaration } from "../prepareContentDeclaration.mjs";
import { writeJSFile } from "./writeJSFile.mjs";
const DEFAULT_NEW_DICTIONARY_PATH = "intlayer-dictionaries";
const formatContentDeclaration = async (dictionary) => {
  const preparedContentDeclaration = await prepareContentDeclaration(dictionary);
  const { filePath, $schema, ...dictionaryWithoutPath } = preparedContentDeclaration;
  const formattedContentDeclaration = {
    $schema: "https://intlayer.org/schema.json",
    ...dictionaryWithoutPath
  };
  return formattedContentDeclaration;
};
const writeContentDeclaration = async (dictionary, config = configuration, newDictionariesPath) => {
  const { content } = config;
  const { baseDir } = content;
  const newDictionaryRelativeLocationPath = newDictionariesPath ?? DEFAULT_NEW_DICTIONARY_PATH;
  const newDictionaryLocationPath = `${baseDir}/${newDictionaryRelativeLocationPath}`;
  const existingDictionary = dictionariesRecord[dictionary.key].filter((el) => el.filePath === dictionary.filePath);
  const filePath = dictionary.filePath;
  const formattedContentDeclaration = await formatContentDeclaration(dictionary);
  if (existingDictionary) {
    if (deepEqual(existingDictionary, dictionary)) {
      return {
        status: "up-to-date",
        path: filePath
      };
    } else {
      if (filePath) {
        await writeFileWithDirectories(filePath, formattedContentDeclaration);
        return { status: "updated", path: filePath };
      } else {
        const contentDeclarationPath = `${newDictionaryLocationPath}/${dictionary.key}.content.json`;
        await writeFileWithDirectories(
          contentDeclarationPath,
          formattedContentDeclaration
        );
        return {
          status: "reimported in new location",
          path: contentDeclarationPath
        };
      }
    }
  } else {
    const contentDeclarationPath = `${newDictionaryLocationPath}/${dictionary.key}.content.json`;
    await writeFileWithDirectories(
      contentDeclarationPath,
      formattedContentDeclaration
    );
    return {
      status: "imported",
      path: contentDeclarationPath
    };
  }
};
const writeFileWithDirectories = async (filePath, data) => {
  try {
    const dir = dirname(filePath);
    const directoryExists = existsSync(dir);
    if (!directoryExists) {
      await mkdir(dir, { recursive: true });
    }
    const extention = extname(filePath);
    const acceptedExtensions = configuration.content.fileExtensions.map(
      (extention2) => extname(extention2)
    );
    if (!acceptedExtensions.includes(extention)) {
      throw new Error(
        `Invalid file extension: ${extention}, file: ${filePath}`
      );
    }
    if (extention === ".json") {
      const jsonDictionary = JSON.stringify(data, null, 2);
      await writeFile(filePath, jsonDictionary);
    } else {
      await writeJSFile(filePath, data);
    }
  } catch (error) {
    throw new Error(`Error writing file to ${filePath}: ${error}`);
  }
};
export {
  writeContentDeclaration
};
//# sourceMappingURL=writeContentDeclaration.mjs.map