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

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

import { existsSync } from "fs";
import * as fsPromises from "fs/promises";
import { basename, dirname, extname } from "path";
import { prepareContentDeclaration } from "@intlayer/chokidar";
import configuration from "@intlayer/config/built";
import dictionariesRecord from "@intlayer/dictionaries-entry";
import deepEqual from "deep-equal";
const DEFAULT_NEW_DICTIONARY_PATH = "intlayer-dictionaries";
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];
  const preparedContentDeclaration = await prepareContentDeclaration(dictionary);
  const { filePath, $schema, ...dictionaryWithoutPath } = preparedContentDeclaration;
  const formattedContentDeclaration = {
    $schema: "https://intlayer.org/schema.json",
    ...dictionaryWithoutPath
  };
  if (existingDictionary) {
    if (deepEqual(existingDictionary, dictionary)) {
      return {
        status: "up-to-date",
        path: filePath
      };
    } else {
      if (filePath) {
        const isDictionaryJSON = filePath.endsWith(".json");
        if (isDictionaryJSON) {
          const contentDeclarationPath = `${baseDir}/${filePath}`;
          await writeFileWithDirectories(
            contentDeclarationPath,
            formattedContentDeclaration
          );
          return { status: "updated", path: contentDeclarationPath };
        } else {
          await fsPromises.rm(filePath);
          const dictionariesDirPath = dirname(filePath);
          const dictionariesFileName = basename(filePath, extname(filePath));
          const newFilePath = `${dictionariesDirPath}/${dictionariesFileName}.json`;
          await writeFileWithDirectories(
            newFilePath,
            formattedContentDeclaration
          );
          return {
            status: "replaced",
            path: newFilePath
          };
        }
      } 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 fsPromises.mkdir(dir, { recursive: true });
    }
    const jsonDictionary = JSON.stringify(data, null, 2);
    await fsPromises.writeFile(filePath, jsonDictionary);
  } catch (error) {
    throw new Error(`Error writing file to ${filePath}: ${error}`);
  }
};
export {
  writeContentDeclaration
};
//# sourceMappingURL=writeContentDeclaration.mjs.map