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

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

import { createDictionaryEntryPoint } from "./createDictionaryEntryPoint/createDictionaryEntryPoint.mjs";
import { buildDictionary } from "./buildIntlayerDictionary/buildIntlayerDictionary.mjs";
import { runOnce } from "./utils/runOnce.mjs";
import { createModuleAugmentation } from "./createType/createModuleAugmentation.mjs";
import { createTypes } from "./createType/createType.mjs";
import { listDictionariesWithStats } from "./listDictionariesPath.mjs";
import { loadDictionaries } from "./loadDictionaries/loadDictionaries.mjs";
import { writeRemoteDictionary } from "./buildIntlayerDictionary/writeRemoteDictionary.mjs";
import { cleanOutputDir } from "./cleanOutputDir.mjs";
import { isCachedConfigurationUpToDate, writeConfiguration } from "./writeConfiguration/index.mjs";
import { stat } from "node:fs/promises";
import { join } from "node:path";
import { colorize, getAppLogger } from "@intlayer/config/logger";
import { cacheDisk } from "@intlayer/config/utils";
import * as ANSIColors from "@intlayer/config/colors";
import packageJson from "@intlayer/config/package.json" with { type: "json" };

//#region src/prepareIntlayer.ts
const DEFAULT_PREPARE_INTLAYER_OPTIONS = {
	clean: false,
	env: "dev",
	format: ["cjs", "esm"],
	cacheTimeoutMs: 1e3 * 60 * 60
};
const prepareIntlayer = async (configuration, options) => {
	const appLogger = getAppLogger(configuration);
	const sentinelPath = join(configuration.system.cacheDir, "intlayer-prepared.lock");
	const versionCache = cacheDisk(configuration, ["intlayer-version"]);
	const intlayerCacheVersion = await versionCache.get();
	const isCorrectVersion = Boolean(intlayerCacheVersion && intlayerCacheVersion === packageJson.version);
	const isConfigSimilar = await isCachedConfigurationUpToDate(configuration);
	const dictionariesWithStats = await listDictionariesWithStats(configuration);
	let isDictionaryChanged = false;
	try {
		const sentinelStats = await stat(sentinelPath);
		isDictionaryChanged = dictionariesWithStats.some((dictionary) => dictionary.stats.mtime.getTime() > sentinelStats.mtime.getTime());
	} catch {}
	const hasPluginLoadDictionaries = (await Promise.all(configuration.plugins ?? [])).some((plugin) => Boolean(plugin.loadDictionaries));
	const { clean, format, forceRun, onIsCached, cacheTimeoutMs, env } = {
		...DEFAULT_PREPARE_INTLAYER_OPTIONS,
		forceRun: !isCorrectVersion || !isConfigSimilar || isDictionaryChanged || hasPluginLoadDictionaries,
		...options ?? {}
	};
	await runOnce(sentinelPath, async () => {
		if (clean || !isCorrectVersion) await cleanOutputDir(configuration);
		await versionCache.set(packageJson.version);
		const preparationStartMs = Date.now();
		appLogger(["Preparing Intlayer", colorize(`(v${packageJson.version})`, ANSIColors.GREY_DARK)]);
		await writeConfiguration(configuration);
		const configurationWrittenTime = Date.now();
		appLogger(["Configuration written", colorize(`(${configurationWrittenTime - preparationStartMs}ms)`, ANSIColors.GREY_DARK)], { isVerbose: true });
		const dictionaries = await loadDictionaries(dictionariesWithStats.map((dictionary) => dictionary.path), configuration);
		const dictionariesLoadedTime = Date.now();
		appLogger(["Content loaded", colorize([dictionaries.remoteDictionaries.length + dictionaries.pluginDictionaries.length > 0 ? [
			`(Total: ${dictionariesLoadedTime - configurationWrittenTime}ms`,
			dictionaries.localDictionaries.length > 0 ? ` - Local: ${dictionaries.time.localDictionaries}ms` : "",
			dictionaries.remoteDictionaries.length > 0 ? ` - Remote: ${dictionaries.time.remoteDictionaries}ms` : "",
			dictionaries.pluginDictionaries.length > 0 ? ` - Plugin: ${dictionaries.time.pluginDictionaries}ms` : "",
			`)`
		].join("") : `(${dictionariesLoadedTime - configurationWrittenTime}ms)`].join(""), ANSIColors.GREY_DARK)], { isVerbose: true });
		const dictionariesOutput = await buildDictionary([
			...dictionaries.localDictionaries,
			...dictionaries.remoteDictionaries,
			...dictionaries.pluginDictionaries
		], configuration, {
			formats: format,
			importOtherDictionaries: false,
			env
		});
		await writeRemoteDictionary(dictionaries.remoteDictionaries, configuration);
		await createTypes(Object.values(dictionariesOutput?.mergedDictionaries ?? {}).map((dictionary) => dictionary.dictionary), configuration);
		await createDictionaryEntryPoint(configuration, { formats: options?.format });
		const dictionariesBuiltTime = Date.now();
		appLogger(["Dictionaries built", colorize(`(${dictionariesBuiltTime - preparationStartMs}ms)`, ANSIColors.GREY_DARK)]);
		await createModuleAugmentation(configuration);
		appLogger(["Module augmentation built", colorize(`(${Date.now() - dictionariesBuiltTime}ms)`, ANSIColors.GREY_DARK)], { isVerbose: true });
		for await (const plugin of configuration.plugins ?? []) {
			const { unmergedDictionaries, mergedDictionaries } = dictionariesOutput;
			await plugin.afterBuild?.({
				dictionaries: {
					unmergedDictionaries,
					mergedDictionaries
				},
				configuration
			});
		}
		appLogger([`Done`, colorize(`${Date.now() - preparationStartMs}ms`, ANSIColors.GREEN)], {
			level: "info",
			isVerbose: true
		});
	}, {
		forceRun,
		onIsCached,
		cacheTimeoutMs
	});
};

//#endregion
export { prepareIntlayer };
//# sourceMappingURL=prepareIntlayer.mjs.map