@intlayer/engine 9.0.0-canary.12

package/dist/esm/scan/scanWebsite.mjs

@@ -0,0 +1,203 @@
+import { mutateScore, toScorePercent } from "./calculateScore.mjs";
+import { byteLength, extractAnchors, extractScriptUrls } from "./parseHtml.mjs";
+import { checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure } from "./checks.mjs";
+import { colorize, logger } from "@intlayer/config/logger";
+import { GREY, GREY_LIGHT } from "@intlayer/config/colors";
+
+//#region src/scan/scanWebsite.ts
+const DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; IntlayerScanBot/1.0; +https://intlayer.org)";
+const DEFAULT_TIMEOUT_MS = 3e4;
+/**
+* Log a recommendation to install `puppeteer` for a deeper scan. Mirrors the
+* style used by other optional-dependency hints across the CLI.
+*/
+const logDeepScanRecommendation = () => {
+	logger([
+		colorize("Recommended: Install", GREY),
+		colorize("puppeteer", GREY_LIGHT),
+		colorize("package to enable a deeper scan (renders client-side content & lazy-loaded chunks). See documentation:", GREY),
+		colorize("https://intlayer.org/doc/concept/cli#scan", GREY_LIGHT)
+	]);
+};
+/**
+* Render the page with a locally installed `puppeteer` to capture
+* client-rendered content, the accurate transfer size, and lazy-loaded chunks.
+*
+* `puppeteer` is imported dynamically through a non-literal specifier so it is
+* never bundled and stays an optional dependency: when it is absent the import
+* rejects and the caller falls back to the basic scan.
+*
+* @returns The deep-scan result, or `null` when `puppeteer` is unavailable.
+*/
+const runDeepScan = async (targetUrl, userAgent, timeoutMs) => {
+	const moduleName = "puppeteer";
+	let puppeteer;
+	try {
+		const mod = await import(moduleName);
+		puppeteer = mod.default ?? mod;
+	} catch {
+		return null;
+	}
+	let browser;
+	try {
+		browser = await puppeteer.launch({
+			headless: true,
+			executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,
+			args: [
+				"--no-sandbox",
+				"--disable-setuid-sandbox",
+				"--disable-dev-shm-usage",
+				"--disable-gpu"
+			]
+		});
+		const page = await browser.newPage();
+		await page.setUserAgent(userAgent);
+		await page.setExtraHTTPHeaders({ "Accept-Language": "en-US,en;q=0.9" });
+		const origin = new URL(targetUrl).origin;
+		const jsResponseMap = /* @__PURE__ */ new Map();
+		let totalPageSize = 0;
+		const pendingResponses = [];
+		page.on("response", (response) => {
+			pendingResponses.push((async () => {
+				try {
+					if (response.status() !== 200) return;
+					const buffer = await response.buffer();
+					totalPageSize += buffer.length;
+					const responseUrl = response.url();
+					if (((response.headers()["content-type"] ?? "").includes("javascript") || /\.(js|mjs|cjs)(\?|$)/.test(responseUrl)) && responseUrl.startsWith(origin)) jsResponseMap.set(responseUrl, buffer.toString("utf-8"));
+				} catch {}
+			})());
+		});
+		await page.goto(targetUrl, {
+			waitUntil: "domcontentloaded",
+			timeout: timeoutMs
+		});
+		await page.waitForNetworkIdle({
+			idleTime: 1e3,
+			timeout: 1e4
+		}).catch(() => {});
+		await Promise.allSettled(pendingResponses);
+		const html = await page.content();
+		const mainBundleUrls = new Set(extractScriptUrls(html, targetUrl));
+		const chunks = Array.from(jsResponseMap.entries()).map(([url, content]) => ({
+			url,
+			isMainBundle: mainBundleUrls.has(url),
+			content
+		}));
+		return {
+			html,
+			totalPageSize,
+			chunks
+		};
+	} finally {
+		if (browser) await browser.close();
+	}
+};
+/** Fetch the raw HTML document, measuring its byte size. */
+const fetchHtml = async (url, userAgent, timeoutMs) => {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		const response = await fetch(url, {
+			headers: {
+				"User-Agent": userAgent,
+				"Accept-Language": "en-US,en;q=0.9"
+			},
+			signal: controller.signal
+		});
+		return {
+			html: await response.text(),
+			finalUrl: response.url || url
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+};
+/**
+* Fetch every eagerly-loaded script. Same-origin scripts keep their content so
+* their locale weight can be analyzed; third-party scripts only contribute to
+* the measured page size (their locale-like keys cause false positives).
+*/
+const fetchScripts = async (scriptUrls, origin, userAgent) => {
+	const chunks = [];
+	let scriptBytes = 0;
+	await Promise.all(scriptUrls.map(async (scriptUrl) => {
+		try {
+			const response = await fetch(scriptUrl, { headers: { "User-Agent": userAgent } });
+			if (!response.ok) return;
+			const content = await response.text();
+			scriptBytes += byteLength(content);
+			if (scriptUrl.startsWith(origin)) chunks.push({
+				url: scriptUrl,
+				isMainBundle: true,
+				content
+			});
+		} catch {}
+	}));
+	return {
+		chunks,
+		scriptBytes
+	};
+};
+/**
+* Scan a single web page for i18n/SEO health and bundle weight.
+*
+* In `deep` mode (default) the page is rendered with a locally installed
+* `puppeteer`; when `puppeteer` is missing the scan transparently falls back to
+* a `basic` fetch-based pass and logs a recommendation to install it.
+*
+* @param targetUrl - The absolute URL to scan.
+* @param options - {@link ScanOptions} controlling depth, timeout and UA.
+* @returns The {@link ScanResult} including score, page size and per-check events.
+*/
+const scanWebsite = async (targetUrl, options = {}) => {
+	const { deep = true, timeoutMs = DEFAULT_TIMEOUT_MS, userAgent = DEFAULT_USER_AGENT } = options;
+	const origin = new URL(targetUrl).origin;
+	let mode = "basic";
+	let html;
+	let totalPageSize;
+	let chunks;
+	const deepResult = deep ? await runDeepScan(targetUrl, userAgent, timeoutMs) : null;
+	if (deepResult) {
+		mode = "deep";
+		html = deepResult.html;
+		chunks = deepResult.chunks;
+		totalPageSize = deepResult.totalPageSize;
+	} else {
+		if (deep) logDeepScanRecommendation();
+		const { html: fetchedHtml, finalUrl } = await fetchHtml(targetUrl, userAgent, timeoutMs);
+		html = fetchedHtml;
+		const { chunks: fetchedChunks, scriptBytes } = await fetchScripts(extractScriptUrls(fetchedHtml, finalUrl), origin, userAgent);
+		chunks = fetchedChunks;
+		totalPageSize = byteLength(fetchedHtml) + scriptBytes;
+	}
+	const htmlSize = byteLength(html);
+	const events = [];
+	const localesSet = /* @__PURE__ */ new Set();
+	const { langTag } = checkHtmlAttributes(html, targetUrl, events);
+	checkCanonical(html, targetUrl, events);
+	checkLinguisticStructure(html, targetUrl, localesSet, events);
+	checkUrlStructure(extractAnchors(html), origin, targetUrl, events);
+	const bundle = checkBundleContent(chunks, html, langTag, targetUrl, totalPageSize, events);
+	await checkRobots(origin, localesSet, userAgent, events);
+	await checkSitemap(origin, localesSet, userAgent, events);
+	const rawScore = events.reduce((score, event) => mutateScore(score, event), {
+		score: 0,
+		totalScore: 0
+	});
+	return {
+		url: targetUrl,
+		mode,
+		totalPageSize,
+		htmlSize,
+		score: toScorePercent(rawScore),
+		rawScore,
+		events,
+		locales: Array.from(localesSet),
+		bundle
+	};
+};
+
+//#endregion
+export { scanWebsite };
+//# sourceMappingURL=scanWebsite.mjs.map

package/dist/esm/scan/scanWebsite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanWebsite.mjs","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"sourcesContent":["import { GREY, GREY_LIGHT } from '@intlayer/config/colors';\nimport { colorize, logger } from '@intlayer/config/logger';\nimport { mutateScore, type Score, toScorePercent } from './calculateScore';\nimport {\n  checkBundleContent,\n  checkCanonical,\n  checkHtmlAttributes,\n  checkLinguisticStructure,\n  checkRobots,\n  checkSitemap,\n  checkUrlStructure,\n} from './checks';\nimport { byteLength, extractAnchors, extractScriptUrls } from './parseHtml';\nimport type {\n  BundleChunkInput,\n  ScanEvent,\n  ScanOptions,\n  ScanResult,\n} from './types';\n\nconst DEFAULT_USER_AGENT =\n  'Mozilla/5.0 (compatible; IntlayerScanBot/1.0; +https://intlayer.org)';\nconst DEFAULT_TIMEOUT_MS = 30_000;\n\n/**\n * Log a recommendation to install `puppeteer` for a deeper scan. Mirrors the\n * style used by other optional-dependency hints across the CLI.\n */\nconst logDeepScanRecommendation = (): void => {\n  logger([\n    colorize('Recommended: Install', GREY),\n    colorize('puppeteer', GREY_LIGHT),\n    colorize(\n      'package to enable a deeper scan (renders client-side content & lazy-loaded chunks). See documentation:',\n      GREY\n    ),\n    colorize('https://intlayer.org/doc/concept/cli#scan', GREY_LIGHT),\n  ]);\n};\n\n/** Outcome of a render-based deep scan. */\ntype DeepScanResult = {\n  html: string;\n  totalPageSize: number;\n  chunks: BundleChunkInput[];\n};\n\n/**\n * Render the page with a locally installed `puppeteer` to capture\n * client-rendered content, the accurate transfer size, and lazy-loaded chunks.\n *\n * `puppeteer` is imported dynamically through a non-literal specifier so it is\n * never bundled and stays an optional dependency: when it is absent the import\n * rejects and the caller falls back to the basic scan.\n *\n * @returns The deep-scan result, or `null` when `puppeteer` is unavailable.\n */\nconst runDeepScan = async (\n  targetUrl: string,\n  userAgent: string,\n  timeoutMs: number\n): Promise<DeepScanResult | null> => {\n  const moduleName = 'puppeteer';\n  // Optional dependency resolved at runtime — typed as `any` because it is not\n  // a declared dependency of this package.\n  let puppeteer: any;\n  try {\n    const mod: any = await import(moduleName);\n    puppeteer = mod.default ?? mod;\n  } catch {\n    return null;\n  }\n\n  let browser: any;\n  try {\n    browser = await puppeteer.launch({\n      headless: true,\n      executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,\n      args: [\n        '--no-sandbox',\n        '--disable-setuid-sandbox',\n        '--disable-dev-shm-usage',\n        '--disable-gpu',\n      ],\n    });\n\n    const page = await browser.newPage();\n    await page.setUserAgent(userAgent);\n    await page.setExtraHTTPHeaders({ 'Accept-Language': 'en-US,en;q=0.9' });\n\n    const origin = new URL(targetUrl).origin;\n    const jsResponseMap = new Map<string, string>();\n    let totalPageSize = 0;\n    const pendingResponses: Promise<void>[] = [];\n\n    page.on('response', (response: any) => {\n      pendingResponses.push(\n        (async () => {\n          try {\n            if (response.status() !== 200) return;\n            const buffer = await response.buffer();\n            totalPageSize += buffer.length;\n\n            const responseUrl: string = response.url();\n            const contentType: string =\n              response.headers()['content-type'] ?? '';\n            const isJavaScript =\n              contentType.includes('javascript') ||\n              /\\.(js|mjs|cjs)(\\?|$)/.test(responseUrl);\n            if (isJavaScript && responseUrl.startsWith(origin)) {\n              jsResponseMap.set(responseUrl, buffer.toString('utf-8'));\n            }\n          } catch {\n            /* response already consumed or aborted */\n          }\n        })()\n      );\n    });\n\n    await page.goto(targetUrl, {\n      waitUntil: 'domcontentloaded',\n      timeout: timeoutMs,\n    });\n    await page\n      .waitForNetworkIdle({ idleTime: 1000, timeout: 10_000 })\n      .catch(() => {\n        /* ok if it never fully idles */\n      });\n    await Promise.allSettled(pendingResponses);\n\n    const html: string = await page.content();\n    const mainBundleUrls = new Set(extractScriptUrls(html, targetUrl));\n    const chunks: BundleChunkInput[] = Array.from(jsResponseMap.entries()).map(\n      ([url, content]) => ({\n        url,\n        isMainBundle: mainBundleUrls.has(url),\n        content,\n      })\n    );\n\n    return { html, totalPageSize, chunks };\n  } finally {\n    if (browser) await browser.close();\n  }\n};\n\n/** Fetch the raw HTML document, measuring its byte size. */\nconst fetchHtml = async (\n  url: string,\n  userAgent: string,\n  timeoutMs: number\n): Promise<{ html: string; finalUrl: string }> => {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n  try {\n    const response = await fetch(url, {\n      headers: { 'User-Agent': userAgent, 'Accept-Language': 'en-US,en;q=0.9' },\n      signal: controller.signal,\n    });\n    const html = await response.text();\n    return { html, finalUrl: response.url || url };\n  } finally {\n    clearTimeout(timer);\n  }\n};\n\n/**\n * Fetch every eagerly-loaded script. Same-origin scripts keep their content so\n * their locale weight can be analyzed; third-party scripts only contribute to\n * the measured page size (their locale-like keys cause false positives).\n */\nconst fetchScripts = async (\n  scriptUrls: string[],\n  origin: string,\n  userAgent: string\n): Promise<{ chunks: BundleChunkInput[]; scriptBytes: number }> => {\n  const chunks: BundleChunkInput[] = [];\n  let scriptBytes = 0;\n\n  await Promise.all(\n    scriptUrls.map(async (scriptUrl) => {\n      try {\n        const response = await fetch(scriptUrl, {\n          headers: { 'User-Agent': userAgent },\n        });\n        if (!response.ok) return;\n        const content = await response.text();\n        scriptBytes += byteLength(content);\n        if (scriptUrl.startsWith(origin)) {\n          chunks.push({ url: scriptUrl, isMainBundle: true, content });\n        }\n      } catch {\n        /* ignore unreachable scripts */\n      }\n    })\n  );\n\n  return { chunks, scriptBytes };\n};\n\n/**\n * Scan a single web page for i18n/SEO health and bundle weight.\n *\n * In `deep` mode (default) the page is rendered with a locally installed\n * `puppeteer`; when `puppeteer` is missing the scan transparently falls back to\n * a `basic` fetch-based pass and logs a recommendation to install it.\n *\n * @param targetUrl - The absolute URL to scan.\n * @param options - {@link ScanOptions} controlling depth, timeout and UA.\n * @returns The {@link ScanResult} including score, page size and per-check events.\n */\nexport const scanWebsite = async (\n  targetUrl: string,\n  options: ScanOptions = {}\n): Promise<ScanResult> => {\n  const {\n    deep = true,\n    timeoutMs = DEFAULT_TIMEOUT_MS,\n    userAgent = DEFAULT_USER_AGENT,\n  } = options;\n\n  const origin = new URL(targetUrl).origin;\n\n  let mode: ScanResult['mode'] = 'basic';\n  let html: string;\n  let totalPageSize: number;\n  let chunks: BundleChunkInput[];\n\n  const deepResult = deep\n    ? await runDeepScan(targetUrl, userAgent, timeoutMs)\n    : null;\n\n  if (deepResult) {\n    mode = 'deep';\n    html = deepResult.html;\n    chunks = deepResult.chunks;\n    totalPageSize = deepResult.totalPageSize;\n  } else {\n    if (deep) logDeepScanRecommendation();\n    const { html: fetchedHtml, finalUrl } = await fetchHtml(\n      targetUrl,\n      userAgent,\n      timeoutMs\n    );\n    html = fetchedHtml;\n    const scriptUrls = extractScriptUrls(fetchedHtml, finalUrl);\n    const { chunks: fetchedChunks, scriptBytes } = await fetchScripts(\n      scriptUrls,\n      origin,\n      userAgent\n    );\n    chunks = fetchedChunks;\n    totalPageSize = byteLength(fetchedHtml) + scriptBytes;\n  }\n\n  const htmlSize = byteLength(html);\n\n  const events: ScanEvent[] = [];\n  const localesSet = new Set<string>();\n\n  const { langTag } = checkHtmlAttributes(html, targetUrl, events);\n  checkCanonical(html, targetUrl, events);\n  checkLinguisticStructure(html, targetUrl, localesSet, events);\n  checkUrlStructure(extractAnchors(html), origin, targetUrl, events);\n  const bundle = checkBundleContent(\n    chunks,\n    html,\n    langTag,\n    targetUrl,\n    totalPageSize,\n    events\n  );\n  await checkRobots(origin, localesSet, userAgent, events);\n  await checkSitemap(origin, localesSet, userAgent, events);\n\n  const rawScore = events.reduce<Score>(\n    (score, event) => mutateScore(score, event),\n    { score: 0, totalScore: 0 }\n  );\n\n  return {\n    url: targetUrl,\n    mode,\n    totalPageSize,\n    htmlSize,\n    score: toScorePercent(rawScore),\n    rawScore,\n    events,\n    locales: Array.from(localesSet),\n    bundle,\n  };\n};\n"],"mappings":";;;;;;;AAoBA,MAAM,qBACJ;AACF,MAAM,qBAAqB;;;;;AAM3B,MAAM,kCAAwC;AAC5C,QAAO;EACL,SAAS,wBAAwB,KAAK;EACtC,SAAS,aAAa,WAAW;EACjC,SACE,0GACA,KACD;EACD,SAAS,6CAA6C,WAAW;EAClE,CAAC;;;;;;;;;;;;AAoBJ,MAAM,cAAc,OAClB,WACA,WACA,cACmC;CACnC,MAAM,aAAa;CAGnB,IAAI;AACJ,KAAI;EACF,MAAM,MAAW,MAAM,OAAO;AAC9B,cAAY,IAAI,WAAW;SACrB;AACN,SAAO;;CAGT,IAAI;AACJ,KAAI;AACF,YAAU,MAAM,UAAU,OAAO;GAC/B,UAAU;GACV,gBAAgB,QAAQ,IAAI;GAC5B,MAAM;IACJ;IACA;IACA;IACA;IACD;GACF,CAAC;EAEF,MAAM,OAAO,MAAM,QAAQ,SAAS;AACpC,QAAM,KAAK,aAAa,UAAU;AAClC,QAAM,KAAK,oBAAoB,EAAE,mBAAmB,kBAAkB,CAAC;EAEvE,MAAM,SAAS,IAAI,IAAI,UAAU,CAAC;EAClC,MAAM,gCAAgB,IAAI,KAAqB;EAC/C,IAAI,gBAAgB;EACpB,MAAM,mBAAoC,EAAE;AAE5C,OAAK,GAAG,aAAa,aAAkB;AACrC,oBAAiB,MACd,YAAY;AACX,QAAI;AACF,SAAI,SAAS,QAAQ,KAAK,IAAK;KAC/B,MAAM,SAAS,MAAM,SAAS,QAAQ;AACtC,sBAAiB,OAAO;KAExB,MAAM,cAAsB,SAAS,KAAK;AAM1C,WAJE,SAAS,SAAS,CAAC,mBAAmB,IAE1B,SAAS,aAAa,IAClC,uBAAuB,KAAK,YAAY,KACtB,YAAY,WAAW,OAAO,CAChD,eAAc,IAAI,aAAa,OAAO,SAAS,QAAQ,CAAC;YAEpD;OAGN,CACL;IACD;AAEF,QAAM,KAAK,KAAK,WAAW;GACzB,WAAW;GACX,SAAS;GACV,CAAC;AACF,QAAM,KACH,mBAAmB;GAAE,UAAU;GAAM,SAAS;GAAQ,CAAC,CACvD,YAAY,GAEX;AACJ,QAAM,QAAQ,WAAW,iBAAiB;EAE1C,MAAM,OAAe,MAAM,KAAK,SAAS;EACzC,MAAM,iBAAiB,IAAI,IAAI,kBAAkB,MAAM,UAAU,CAAC;EAClE,MAAM,SAA6B,MAAM,KAAK,cAAc,SAAS,CAAC,CAAC,KACpE,CAAC,KAAK,cAAc;GACnB;GACA,cAAc,eAAe,IAAI,IAAI;GACrC;GACD,EACF;AAED,SAAO;GAAE;GAAM;GAAe;GAAQ;WAC9B;AACR,MAAI,QAAS,OAAM,QAAQ,OAAO;;;;AAKtC,MAAM,YAAY,OAChB,KACA,WACA,cACgD;CAChD,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,QAAQ,iBAAiB,WAAW,OAAO,EAAE,UAAU;AAC7D,KAAI;EACF,MAAM,WAAW,MAAM,MAAM,KAAK;GAChC,SAAS;IAAE,cAAc;IAAW,mBAAmB;IAAkB;GACzE,QAAQ,WAAW;GACpB,CAAC;AAEF,SAAO;GAAE,YADU,SAAS,MAAM;GACnB,UAAU,SAAS,OAAO;GAAK;WACtC;AACR,eAAa,MAAM;;;;;;;;AASvB,MAAM,eAAe,OACnB,YACA,QACA,cACiE;CACjE,MAAM,SAA6B,EAAE;CACrC,IAAI,cAAc;AAElB,OAAM,QAAQ,IACZ,WAAW,IAAI,OAAO,cAAc;AAClC,MAAI;GACF,MAAM,WAAW,MAAM,MAAM,WAAW,EACtC,SAAS,EAAE,cAAc,WAAW,EACrC,CAAC;AACF,OAAI,CAAC,SAAS,GAAI;GAClB,MAAM,UAAU,MAAM,SAAS,MAAM;AACrC,kBAAe,WAAW,QAAQ;AAClC,OAAI,UAAU,WAAW,OAAO,CAC9B,QAAO,KAAK;IAAE,KAAK;IAAW,cAAc;IAAM;IAAS,CAAC;UAExD;GAGR,CACH;AAED,QAAO;EAAE;EAAQ;EAAa;;;;;;;;;;;;;AAchC,MAAa,cAAc,OACzB,WACA,UAAuB,EAAE,KACD;CACxB,MAAM,EACJ,OAAO,MACP,YAAY,oBACZ,YAAY,uBACV;CAEJ,MAAM,SAAS,IAAI,IAAI,UAAU,CAAC;CAElC,IAAI,OAA2B;CAC/B,IAAI;CACJ,IAAI;CACJ,IAAI;CAEJ,MAAM,aAAa,OACf,MAAM,YAAY,WAAW,WAAW,UAAU,GAClD;AAEJ,KAAI,YAAY;AACd,SAAO;AACP,SAAO,WAAW;AAClB,WAAS,WAAW;AACpB,kBAAgB,WAAW;QACtB;AACL,MAAI,KAAM,4BAA2B;EACrC,MAAM,EAAE,MAAM,aAAa,aAAa,MAAM,UAC5C,WACA,WACA,UACD;AACD,SAAO;EAEP,MAAM,EAAE,QAAQ,eAAe,gBAAgB,MAAM,aADlC,kBAAkB,aAAa,SAEtC,EACV,QACA,UACD;AACD,WAAS;AACT,kBAAgB,WAAW,YAAY,GAAG;;CAG5C,MAAM,WAAW,WAAW,KAAK;CAEjC,MAAM,SAAsB,EAAE;CAC9B,MAAM,6BAAa,IAAI,KAAa;CAEpC,MAAM,EAAE,YAAY,oBAAoB,MAAM,WAAW,OAAO;AAChE,gBAAe,MAAM,WAAW,OAAO;AACvC,0BAAyB,MAAM,WAAW,YAAY,OAAO;AAC7D,mBAAkB,eAAe,KAAK,EAAE,QAAQ,WAAW,OAAO;CAClE,MAAM,SAAS,mBACb,QACA,MACA,SACA,WACA,eACA,OACD;AACD,OAAM,YAAY,QAAQ,YAAY,WAAW,OAAO;AACxD,OAAM,aAAa,QAAQ,YAAY,WAAW,OAAO;CAEzD,MAAM,WAAW,OAAO,QACrB,OAAO,UAAU,YAAY,OAAO,MAAM,EAC3C;EAAE,OAAO;EAAG,YAAY;EAAG,CAC5B;AAED,QAAO;EACL,KAAK;EACL;EACA;EACA;EACA,OAAO,eAAe,SAAS;EAC/B;EACA;EACA,SAAS,MAAM,KAAK,WAAW;EAC/B;EACD"}

package/dist/esm/utils/autoDecorateContent.mjs

@@ -0,0 +1,87 @@
+import { getMarkdownMetadata } from "@intlayer/core/markdown";
+import { getInsertionValues, html, insert, md } from "@intlayer/core/transpiler";
+import * as NodeTypes from "@intlayer/types/nodeType";
+
+//#region src/utils/autoDecorateContent.ts
+/**
+* Check if a string is a markdown string
+*/
+const isMarkdown = (str) => {
+	return [
+		/^\s*---/m,
+		/^\s*#+\s/m,
+		/^\s*[-*+]\s/m,
+		/^\s*\d+\.\s/m,
+		/^\s*>\s/m,
+		/\[.+\]\(.+\)/,
+		/!\[.+\]\(.+\)/,
+		/`{1,3}.+`{1,3}/,
+		/\*\*.+\*\*/,
+		/__.+__/,
+		/<(https?:\/\/[^\s>]+)>/
+	].some((pattern) => pattern.test(str));
+};
+/**
+* Check if a string is an insertion string
+*/
+const isInsertion = (str) => getInsertionValues(str).length > 0;
+/**
+* Check if a string is an HTML/JSX string
+* Matches:
+* - <Tag>
+* - </Tag>
+* - <Tag />
+* - <Tag attribute="value">
+* - <Component.SubComponent>
+*/
+const isHTML = (str) => {
+	return /<[a-zA-Z][a-zA-Z0-9\-.]*(\s+[^>]*)?\/?>/.test(str) || /<\/[a-zA-Z][a-zA-Z0-9\-.]*\s*>/.test(str);
+};
+const leafNodeTypes = [
+	NodeTypes.HTML,
+	NodeTypes.MARKDOWN,
+	NodeTypes.INSERTION,
+	NodeTypes.FILE,
+	NodeTypes.REACT_NODE,
+	NodeTypes.TEXT,
+	NodeTypes.NUMBER,
+	NodeTypes.BOOLEAN,
+	NodeTypes.NULL,
+	NodeTypes.UNKNOWN
+];
+/**
+* Automatically decorate content strings with md() or insert() if they match
+*/
+const autoDecorateContent = (content, options = true) => {
+	if (options === false) return content;
+	const { markdown = true, html: htmlOption = true, insertion = true } = typeof options === "object" ? options : {};
+	if (typeof content === "string") {
+		if (markdown && isMarkdown(content)) return {
+			...md(content),
+			metadata: getMarkdownMetadata(content)
+		};
+		if (htmlOption && isHTML(content)) return html(content);
+		if (insertion && isInsertion(content)) return insert(content);
+		return content;
+	}
+	if (Array.isArray(content)) return content.map((item) => autoDecorateContent(item, options));
+	if (content && typeof content === "object") {
+		if ("nodeType" in content) {
+			const nodeType = content.nodeType;
+			if (leafNodeTypes.includes(nodeType)) return content;
+			if (nodeType in content) return {
+				...content,
+				[nodeType]: autoDecorateContent(content[nodeType], options)
+			};
+			return content;
+		}
+		const result = {};
+		for (const key of Object.keys(content)) result[key] = autoDecorateContent(content[key], options);
+		return result;
+	}
+	return content;
+};
+
+//#endregion
+export { autoDecorateContent };
+//# sourceMappingURL=autoDecorateContent.mjs.map

package/dist/esm/utils/autoDecorateContent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoDecorateContent.mjs","names":[],"sources":["../../../src/utils/autoDecorateContent.ts"],"sourcesContent":["import { getMarkdownMetadata } from '@intlayer/core/markdown';\nimport {\n  getInsertionValues,\n  html,\n  insert,\n  md,\n} from '@intlayer/core/transpiler';\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\n/**\n * Check if a string is a markdown string\n */\nconst isMarkdown = (str: string): boolean => {\n  // Check for common markdown indicators\n  const patterns = [\n    /^\\s*---/m, // Front Matter\n    /^\\s*#+\\s/m, // Headers: # Title\n    /^\\s*[-*+]\\s/m, // Unordered lists: - Item or * Item\n    /^\\s*\\d+\\.\\s/m, // Ordered lists: 1. Item\n    /^\\s*>\\s/m, // Blockquotes: > Quote\n    /\\[.+\\]\\(.+\\)/, // Links: [text](url)\n    /!\\[.+\\]\\(.+\\)/, // Images: ![alt](url)\n    /`{1,3}.+`{1,3}/, // Code blocks or inline code: `code` or ```code```\n    /\\*\\*.+\\*\\*/, // Bold: **text**\n    /__.+__/, // Bold: __text__\n    /<(https?:\\/\\/[^\\s>]+)>/, // Autolinks: <http://...>\n  ];\n\n  return patterns.some((pattern) => pattern.test(str));\n};\n\n/**\n * Check if a string is an insertion string\n */\nconst isInsertion = (str: string): boolean =>\n  getInsertionValues(str).length > 0;\n\n/**\n * Check if a string is an HTML/JSX string\n * Matches:\n * - <Tag>\n * - </Tag>\n * - <Tag />\n * - <Tag attribute=\"value\">\n * - <Component.SubComponent>\n */\nconst isHTML = (str: string): boolean => {\n  // 1. Matches opening or self-closing tags: <Tag ... > or <Tag ... />\n  //    - Must start with < followed by a letter (to avoid math comparisons like a < b)\n  //    - Allows alphanumeric, hyphens, and dots (for Namespaced components) in tag name\n  //    - Allows attributes until the closing >\n  const openTagRegex = /<[a-zA-Z][a-zA-Z0-9\\-.]*(\\s+[^>]*)?\\/?>/;\n\n  // 2. Matches closing tags: </Tag>\n  const closeTagRegex = /<\\/[a-zA-Z][a-zA-Z0-9\\-.]*\\s*>/;\n\n  return openTagRegex.test(str) || closeTagRegex.test(str);\n};\n\nconst leafNodeTypes: string[] = [\n  NodeTypes.HTML,\n  NodeTypes.MARKDOWN,\n  NodeTypes.INSERTION,\n  NodeTypes.FILE,\n  NodeTypes.REACT_NODE,\n  NodeTypes.TEXT,\n  NodeTypes.NUMBER,\n  NodeTypes.BOOLEAN,\n  NodeTypes.NULL,\n  NodeTypes.UNKNOWN,\n];\n\ntype AutoTransformationOptions = {\n  markdown?: boolean;\n  html?: boolean;\n  insertion?: boolean;\n};\n\n/**\n * Automatically decorate content strings with md() or insert() if they match\n */\nexport const autoDecorateContent = (\n  content: any,\n  options: boolean | AutoTransformationOptions = true\n): any => {\n  if (options === false) {\n    return content;\n  }\n\n  const {\n    markdown = true,\n    html: htmlOption = true,\n    insertion = true,\n  } = typeof options === 'object' ? options : {};\n\n  if (typeof content === 'string') {\n    if (markdown && isMarkdown(content)) {\n      const markdownNode = md(content);\n\n      return {\n        ...markdownNode,\n        metadata: getMarkdownMetadata(content),\n      };\n    }\n\n    if (htmlOption && isHTML(content)) {\n      return html(content);\n    }\n\n    if (insertion && isInsertion(content)) {\n      return insert(content);\n    }\n\n    return content;\n  }\n\n  if (Array.isArray(content)) {\n    return content.map((item) => autoDecorateContent(item, options));\n  }\n\n  if (content && typeof content === 'object') {\n    // If it's already a decorated node (has nodeType)\n    if ('nodeType' in content) {\n      const nodeType = content.nodeType;\n\n      // If it's a leaf node type, don't re-decorate its content\n      if (leafNodeTypes.includes(nodeType)) {\n        return content;\n      }\n\n      // If it's a container node type (like translation, enumeration, etc.), recurse into its content field\n      if (nodeType in content) {\n        return {\n          ...content,\n          [nodeType]: autoDecorateContent(content[nodeType], options),\n        };\n      }\n\n      return content;\n    }\n\n    // Plain object, recurse into all keys\n    const result: Record<string, any> = {};\n    for (const key of Object.keys(content)) {\n      result[key] = autoDecorateContent(content[key], options);\n    }\n    return result;\n  }\n\n  return content;\n};\n"],"mappings":";;;;;;;;AAYA,MAAM,cAAc,QAAyB;AAgB3C,QAAO;EAbL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGa,CAAC,MAAM,YAAY,QAAQ,KAAK,IAAI,CAAC;;;;;AAMtD,MAAM,eAAe,QACnB,mBAAmB,IAAI,CAAC,SAAS;;;;;;;;;;AAWnC,MAAM,UAAU,QAAyB;AAUvC,QAAO,0CAAa,KAAK,IAAI,IAAI,iCAAc,KAAK,IAAI;;AAG1D,MAAM,gBAA0B;CAC9B,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACX;;;;AAWD,MAAa,uBACX,SACA,UAA+C,SACvC;AACR,KAAI,YAAY,MACd,QAAO;CAGT,MAAM,EACJ,WAAW,MACX,MAAM,aAAa,MACnB,YAAY,SACV,OAAO,YAAY,WAAW,UAAU,EAAE;AAE9C,KAAI,OAAO,YAAY,UAAU;AAC/B,MAAI,YAAY,WAAW,QAAQ,CAGjC,QAAO;GACL,GAHmB,GAAG,QAGP;GACf,UAAU,oBAAoB,QAAQ;GACvC;AAGH,MAAI,cAAc,OAAO,QAAQ,CAC/B,QAAO,KAAK,QAAQ;AAGtB,MAAI,aAAa,YAAY,QAAQ,CACnC,QAAO,OAAO,QAAQ;AAGxB,SAAO;;AAGT,KAAI,MAAM,QAAQ,QAAQ,CACxB,QAAO,QAAQ,KAAK,SAAS,oBAAoB,MAAM,QAAQ,CAAC;AAGlE,KAAI,WAAW,OAAO,YAAY,UAAU;AAE1C,MAAI,cAAc,SAAS;GACzB,MAAM,WAAW,QAAQ;AAGzB,OAAI,cAAc,SAAS,SAAS,CAClC,QAAO;AAIT,OAAI,YAAY,QACd,QAAO;IACL,GAAG;KACF,WAAW,oBAAoB,QAAQ,WAAW,QAAQ;IAC5D;AAGH,UAAO;;EAIT,MAAM,SAA8B,EAAE;AACtC,OAAK,MAAM,OAAO,OAAO,KAAK,QAAQ,CACpC,QAAO,OAAO,oBAAoB,QAAQ,MAAM,QAAQ;AAE1D,SAAO;;AAGT,QAAO"}

package/dist/esm/utils/buildComponentFilesList.mjs

@@ -0,0 +1,91 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import fg from "fast-glob";
+import { normalizePath } from "@intlayer/config/utils";
+import { TRAVERSE_PATTERN } from "@intlayer/config/defaultValues";
+
+//#region src/utils/buildComponentFilesList.ts
+/**
+* Normalizes a pattern value to an array
+*/
+const normalizeToArray = (value) => Array.isArray(value) ? value : [value];
+/**
+* Remove directories that are subdirectories of others in the list so files
+* are never scanned twice.
+* Example: ['/root', '/root/src'] → ['/root']
+*/
+const getDistinctRootDirs = (dirs) => {
+	const uniqueDirs = Array.from(new Set(dirs.map((dir) => resolve(dir))));
+	uniqueDirs.sort((a, b) => a.length - b.length);
+	return uniqueDirs.reduce((acc, dir) => {
+		if (!acc.some((parent) => {
+			const rel = relative(parent, dir);
+			return !rel.startsWith("..") && !isAbsolute(rel) && rel !== "";
+		})) acc.push(dir);
+		return acc;
+	}, []);
+};
+/**
+* Returns true when the resolved path passes through a `node_modules` segment.
+* Works on both POSIX and Windows paths.
+*/
+const isInsideNodeModules = (dir) => resolve(dir).split(sep).includes("node_modules");
+/**
+* Default exclude patterns derived from TRAVERSE_PATTERN.
+* Extracted once so the function body can reference them without re-computing.
+*/
+const DEFAULT_EXCLUDE_PATTERNS = TRAVERSE_PATTERN.filter((p) => typeof p === "string" && p.startsWith("!")).map((p) => p.slice(1));
+/**
+* Builds a deduplicated list of absolute file paths matching the given patterns.
+*
+* Handles multiple root directories (deduplicates overlapping roots), exclude
+* patterns, negation patterns embedded in `traversePattern`, and optional
+* dot-file inclusion.
+*
+* Special case: `codeDir` entries that live inside `node_modules` (e.g. a
+* design-system package installed as a workspace dependency) are scanned as
+* their own explicit roots. They are NOT collapsed into the project root so
+* the `*\/node_modules\/**` exclusion does not silently drop them.
+*
+* @example
+* // Single root with excludes
+* const files = buildComponentFilesList(config);
+*
+* @example
+* // Design-system package inside node_modules is still scanned
+* // intlayer.config.ts: { content: { codeDir: ['node_modules/my-ds/src'] } }
+* const files = buildComponentFilesList(config);
+*/
+const buildComponentFilesList = (config, excludePattern) => {
+	const traversePattern = config.build.traversePattern;
+	const compilerTransformPattern = config.compiler.transformPattern;
+	const contentDeclarationPattern = config.content.fileExtensions.map((ext) => `/**/*${ext}`);
+	const patterns = [...traversePattern, ...normalizeToArray(compilerTransformPattern)].filter((pattern) => typeof pattern === "string").filter((pattern) => !pattern.startsWith("!")).map(normalizePath);
+	const userExcludes = traversePattern.filter((pattern) => typeof pattern === "string" && pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+	const baseExcludePatterns = Array.from(new Set([
+		...DEFAULT_EXCLUDE_PATTERNS,
+		...userExcludes,
+		...excludePattern ?? [],
+		...contentDeclarationPattern
+	])).filter((pattern) => typeof pattern === "string").map(normalizePath);
+	const resolvedCodeDirs = (config.content.codeDir ?? []).map((dir) => resolve(dir));
+	const inNodeModulesCodeDirs = resolvedCodeDirs.filter(isInsideNodeModules);
+	const normalCodeDirs = resolvedCodeDirs.filter((dir) => !isInsideNodeModules(dir));
+	const normalFiles = getDistinctRootDirs([config.system.baseDir, ...normalCodeDirs]).flatMap((root) => fg.sync(patterns, {
+		cwd: root,
+		ignore: baseExcludePatterns,
+		absolute: true,
+		dot: true
+	}));
+	const nodeModulesExcludePatterns = baseExcludePatterns.filter((pattern) => !pattern.includes("node_modules"));
+	const nodeModulesFiles = inNodeModulesCodeDirs.flatMap((dir) => fg.sync(patterns, {
+		cwd: dir,
+		ignore: nodeModulesExcludePatterns,
+		absolute: true,
+		dot: false
+	}));
+	return Array.from(new Set([...normalFiles, ...nodeModulesFiles]));
+};
+
+//#endregion
+export { buildComponentFilesList };
+//# sourceMappingURL=buildComponentFilesList.mjs.map

package/dist/esm/utils/buildComponentFilesList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildComponentFilesList.mjs","names":[],"sources":["../../../src/utils/buildComponentFilesList.ts"],"sourcesContent":["import { isAbsolute, relative, resolve, sep } from 'node:path';\nimport { TRAVERSE_PATTERN } from '@intlayer/config/defaultValues';\nimport { normalizePath } from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport fg from 'fast-glob';\n\n/**\n * Normalizes a pattern value to an array\n */\nconst normalizeToArray = <T>(value: T | T[]): T[] =>\n  Array.isArray(value) ? value : [value];\n\n/**\n * Remove directories that are subdirectories of others in the list so files\n * are never scanned twice.\n * Example: ['/root', '/root/src'] → ['/root']\n */\nconst getDistinctRootDirs = (dirs: string[]): string[] => {\n  const uniqueDirs = Array.from(new Set(dirs.map((dir) => resolve(dir))));\n  uniqueDirs.sort((a, b) => a.length - b.length);\n\n  return uniqueDirs.reduce((acc: string[], dir) => {\n    const isNested = acc.some((parent) => {\n      const rel = relative(parent, dir);\n\n      return !rel.startsWith('..') && !isAbsolute(rel) && rel !== '';\n    });\n    if (!isNested) acc.push(dir);\n\n    return acc;\n  }, []);\n};\n\n/**\n * Returns true when the resolved path passes through a `node_modules` segment.\n * Works on both POSIX and Windows paths.\n */\nconst isInsideNodeModules = (dir: string): boolean =>\n  resolve(dir).split(sep).includes('node_modules');\n\n/**\n * Default exclude patterns derived from TRAVERSE_PATTERN.\n * Extracted once so the function body can reference them without re-computing.\n */\nconst DEFAULT_EXCLUDE_PATTERNS: string[] = TRAVERSE_PATTERN.filter(\n  (p): p is string => typeof p === 'string' && p.startsWith('!')\n).map((p) => p.slice(1));\n\n/**\n * Builds a deduplicated list of absolute file paths matching the given patterns.\n *\n * Handles multiple root directories (deduplicates overlapping roots), exclude\n * patterns, negation patterns embedded in `traversePattern`, and optional\n * dot-file inclusion.\n *\n * Special case: `codeDir` entries that live inside `node_modules` (e.g. a\n * design-system package installed as a workspace dependency) are scanned as\n * their own explicit roots. They are NOT collapsed into the project root so\n * the `*\\/node_modules\\/**` exclusion does not silently drop them.\n *\n * @example\n * // Single root with excludes\n * const files = buildComponentFilesList(config);\n *\n * @example\n * // Design-system package inside node_modules is still scanned\n * // intlayer.config.ts: { content: { codeDir: ['node_modules/my-ds/src'] } }\n * const files = buildComponentFilesList(config);\n */\nexport const buildComponentFilesList = (\n  config: IntlayerConfig,\n  excludePattern?: string[]\n): string[] => {\n  const traversePattern = config.build.traversePattern;\n  const compilerTransformPattern = config.compiler.transformPattern;\n  const contentDeclarationPattern = config.content.fileExtensions.map(\n    (ext) => `/**/*${ext}`\n  );\n\n  const patterns = [\n    ...traversePattern,\n    ...normalizeToArray(compilerTransformPattern),\n  ]\n    .filter((pattern) => typeof pattern === 'string')\n    .filter((pattern) => !pattern.startsWith('!'))\n    .map(normalizePath);\n\n  // User-supplied negations from traversePattern\n  const userExcludes = traversePattern\n    .filter(\n      (pattern): pattern is string =>\n        typeof pattern === 'string' && pattern.startsWith('!')\n    )\n    .map((pattern) => pattern.slice(1));\n\n  // Full exclude list: defaults (from TRAVERSE_PATTERN) + user overrides + caller extras + content files.\n  // DEFAULT_EXCLUDE_PATTERNS acts as a safety floor — if the user provides a\n  // partial traversePattern that omits some defaults, they are still applied.\n  const baseExcludePatterns = Array.from(\n    new Set([\n      ...DEFAULT_EXCLUDE_PATTERNS,\n      ...userExcludes,\n      ...(excludePattern ?? []),\n      ...contentDeclarationPattern,\n    ])\n  )\n    .filter((pattern): pattern is string => typeof pattern === 'string')\n    .map(normalizePath);\n\n  // Separate codeDir entries that live inside node_modules.\n  // getDistinctRootDirs would collapse them into the project root, after which\n  // the **/node_modules/** ignore would silently exclude them.\n  const resolvedCodeDirs = (config.content.codeDir ?? []).map((dir) =>\n    resolve(dir)\n  );\n  const inNodeModulesCodeDirs = resolvedCodeDirs.filter(isInsideNodeModules);\n  const normalCodeDirs = resolvedCodeDirs.filter(\n    (dir) => !isInsideNodeModules(dir)\n  );\n\n  // Normal roots: project base + regular codeDir entries, deduplicated.\n  const normalRoots = getDistinctRootDirs([\n    config.system.baseDir,\n    ...normalCodeDirs,\n  ]);\n\n  const normalFiles = normalRoots.flatMap((root) =>\n    fg.sync(patterns, {\n      cwd: root,\n      ignore: baseExcludePatterns,\n      absolute: true,\n      dot: true, // needed for .intlayer and similar\n    })\n  );\n\n  // node_modules codeDir roots: scanned directly from the package root.\n  // **/node_modules/** is removed from the ignore list so it doesn't block\n  // the scan (it is still applied inside the package for nested node_modules).\n  const nodeModulesExcludePatterns = baseExcludePatterns.filter(\n    (pattern) => !pattern.includes('node_modules')\n  );\n\n  const nodeModulesFiles = inNodeModulesCodeDirs.flatMap((dir) =>\n    fg.sync(patterns, {\n      cwd: dir,\n      ignore: nodeModulesExcludePatterns,\n      absolute: true,\n      dot: false,\n    })\n  );\n\n  return Array.from(new Set([...normalFiles, ...nodeModulesFiles]));\n};\n"],"mappings":";;;;;;;;;AASA,MAAM,oBAAuB,UAC3B,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;AAOxC,MAAM,uBAAuB,SAA6B;CACxD,MAAM,aAAa,MAAM,KAAK,IAAI,IAAI,KAAK,KAAK,QAAQ,QAAQ,IAAI,CAAC,CAAC,CAAC;AACvE,YAAW,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,OAAO;AAE9C,QAAO,WAAW,QAAQ,KAAe,QAAQ;AAM/C,MAAI,CALa,IAAI,MAAM,WAAW;GACpC,MAAM,MAAM,SAAS,QAAQ,IAAI;AAEjC,UAAO,CAAC,IAAI,WAAW,KAAK,IAAI,CAAC,WAAW,IAAI,IAAI,QAAQ;IAEjD,CAAE,KAAI,KAAK,IAAI;AAE5B,SAAO;IACN,EAAE,CAAC;;;;;;AAOR,MAAM,uBAAuB,QAC3B,QAAQ,IAAI,CAAC,MAAM,IAAI,CAAC,SAAS,eAAe;;;;;AAMlD,MAAM,2BAAqC,iBAAiB,QACzD,MAAmB,OAAO,MAAM,YAAY,EAAE,WAAW,IAAI,CAC/D,CAAC,KAAK,MAAM,EAAE,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuBxB,MAAa,2BACX,QACA,mBACa;CACb,MAAM,kBAAkB,OAAO,MAAM;CACrC,MAAM,2BAA2B,OAAO,SAAS;CACjD,MAAM,4BAA4B,OAAO,QAAQ,eAAe,KAC7D,QAAQ,QAAQ,MAClB;CAED,MAAM,WAAW,CACf,GAAG,iBACH,GAAG,iBAAiB,yBAAyB,CAC9C,CACE,QAAQ,YAAY,OAAO,YAAY,SAAS,CAChD,QAAQ,YAAY,CAAC,QAAQ,WAAW,IAAI,CAAC,CAC7C,IAAI,cAAc;CAGrB,MAAM,eAAe,gBAClB,QACE,YACC,OAAO,YAAY,YAAY,QAAQ,WAAW,IAAI,CACzD,CACA,KAAK,YAAY,QAAQ,MAAM,EAAE,CAAC;CAKrC,MAAM,sBAAsB,MAAM,KAChC,IAAI,IAAI;EACN,GAAG;EACH,GAAG;EACH,GAAI,kBAAkB,EAAE;EACxB,GAAG;EACJ,CAAC,CACH,CACE,QAAQ,YAA+B,OAAO,YAAY,SAAS,CACnE,IAAI,cAAc;CAKrB,MAAM,oBAAoB,OAAO,QAAQ,WAAW,EAAE,EAAE,KAAK,QAC3D,QAAQ,IAAI,CACb;CACD,MAAM,wBAAwB,iBAAiB,OAAO,oBAAoB;CAC1E,MAAM,iBAAiB,iBAAiB,QACrC,QAAQ,CAAC,oBAAoB,IAAI,CACnC;CAQD,MAAM,cALc,oBAAoB,CACtC,OAAO,OAAO,SACd,GAAG,eACJ,CAE8B,CAAC,SAAS,SACvC,GAAG,KAAK,UAAU;EAChB,KAAK;EACL,QAAQ;EACR,UAAU;EACV,KAAK;EACN,CAAC,CACH;CAKD,MAAM,6BAA6B,oBAAoB,QACpD,YAAY,CAAC,QAAQ,SAAS,eAAe,CAC/C;CAED,MAAM,mBAAmB,sBAAsB,SAAS,QACtD,GAAG,KAAK,UAAU;EAChB,KAAK;EACL,QAAQ;EACR,UAAU;EACV,KAAK;EACN,CAAC,CACH;AAED,QAAO,MAAM,KAAK,IAAI,IAAI,CAAC,GAAG,aAAa,GAAG,iBAAiB,CAAC,CAAC"}

package/dist/esm/utils/buildFilesList.mjs

@@ -0,0 +1,80 @@
+import { isAbsolute, normalize, relative, resolve } from "node:path";
+import fg from "fast-glob";
+
+//#region src/utils/buildFilesList.ts
+/**
+* Normalizes a pattern value to an array
+*/
+const normalizeToArray = (value) => Array.isArray(value) ? value : [value];
+/**
+* Remove directories that are subdirectories of others in the list so files
+* are never scanned twice.
+* Example: ['/root', '/root/src'] → ['/root']
+*/
+const getDistinctRootDirs = (dirs) => {
+	const uniqueDirs = Array.from(new Set(dirs.map((dir) => resolve(dir))));
+	uniqueDirs.sort((a, b) => a.length - b.length);
+	return uniqueDirs.reduce((acc, dir) => {
+		if (!acc.some((parent) => {
+			const rel = relative(parent, dir);
+			return !rel.startsWith("..") && !isAbsolute(rel) && rel !== "";
+		})) acc.push(dir);
+		return acc;
+	}, []);
+};
+/**
+* Builds a deduplicated list of absolute file paths matching the given patterns.
+*
+* Handles multiple root directories (deduplicates overlapping roots), exclude
+* patterns, negation patterns embedded in `transformPattern`, and optional
+* dot-file inclusion.
+*
+* @example
+* // Single root with excludes
+* const files = buildComponentFilesList({
+*   transformPattern: 'src/**\/*.{ts,tsx}',
+*   excludePattern: ['**\/node_modules\/**'],
+*   baseDir: '/path/to/project',
+* });
+*
+* @example
+* // Multiple roots (e.g. baseDir + codeDir), dot files included
+* const files = buildComponentFilesList({
+*   transformPattern: config.build.traversePattern,
+*   baseDir: [config.system.baseDir, ...config.content.codeDir],
+*   dot: true,
+* });
+*/
+const buildComponentFilesList = (config) => {
+	const { transformPattern, excludePattern = [], baseDir, dot = false } = config;
+	const patterns = normalizeToArray(transformPattern).filter((pattern) => typeof pattern === "string" && !pattern.startsWith("!")).map(normalize);
+	const excludePatterns = [...normalizeToArray(excludePattern), ...normalizeToArray(transformPattern).filter((pattern) => typeof pattern === "string" && pattern.startsWith("!")).map((pattern) => pattern.slice(1))].filter((pattern) => typeof pattern === "string").map(normalize);
+	const roots = getDistinctRootDirs(normalizeToArray(baseDir));
+	return Array.from(new Set(roots.flatMap((root) => fg.sync(patterns, {
+		cwd: root,
+		ignore: excludePatterns,
+		absolute: true,
+		dot
+	}))));
+};
+/**
+* Convenience wrapper that derives all file-list options directly from an
+* `IntlayerConfig` object.
+*
+* Scans `[baseDir, ...codeDir]` using `build.traversePattern`, excludes
+* content declaration file extensions and any `compiler.excludePattern`
+* entries defined in the configuration, and includes dot files.
+*/
+const buildComponentFilesListFromConfig = (intlayerConfig) => {
+	const { build: { traversePattern }, system: { baseDir }, content: { codeDir, fileExtensions }, compiler: { excludePattern } } = intlayerConfig;
+	return buildComponentFilesList({
+		transformPattern: traversePattern,
+		excludePattern: [...fileExtensions.map((ext) => `**/*${ext}`), ...Array.isArray(excludePattern) ? excludePattern : [excludePattern]].filter((p) => typeof p === "string"),
+		baseDir: [baseDir, ...codeDir],
+		dot: true
+	});
+};
+
+//#endregion
+export { buildComponentFilesList, buildComponentFilesListFromConfig };
+//# sourceMappingURL=buildFilesList.mjs.map

package/dist/esm/utils/buildFilesList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildFilesList.mjs","names":[],"sources":["../../../src/utils/buildFilesList.ts"],"sourcesContent":["import { isAbsolute, normalize, relative, resolve } from 'node:path';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport fg from 'fast-glob';\n\n/**\n * Options for building the files list\n */\nexport type BuildComponentFilesListOptions = {\n  /**\n   * Glob patterns to match files\n   */\n  transformPattern: string | string[];\n  /**\n   * Glob patterns to exclude files\n   */\n  excludePattern?: string | string[];\n  /**\n   * Base directory (or directories) for file resolution.\n   * When multiple directories are provided, subdirectories of others are\n   * automatically deduplicated so files are never scanned twice.\n   */\n  baseDir: string | string[];\n  /**\n   * Whether to include dot-prefixed files and directories (default: false)\n   */\n  dot?: boolean;\n};\n\n/**\n * Normalizes a pattern value to an array\n */\nconst normalizeToArray = <T>(value: T | T[]): T[] =>\n  Array.isArray(value) ? value : [value];\n\n/**\n * Remove directories that are subdirectories of others in the list so files\n * are never scanned twice.\n * Example: ['/root', '/root/src'] → ['/root']\n */\nconst getDistinctRootDirs = (dirs: string[]): string[] => {\n  const uniqueDirs = Array.from(new Set(dirs.map((dir) => resolve(dir))));\n  uniqueDirs.sort((a, b) => a.length - b.length);\n\n  return uniqueDirs.reduce((acc: string[], dir) => {\n    const isNested = acc.some((parent) => {\n      const rel = relative(parent, dir);\n      return !rel.startsWith('..') && !isAbsolute(rel) && rel !== '';\n    });\n    if (!isNested) acc.push(dir);\n    return acc;\n  }, []);\n};\n\n/**\n * Builds a deduplicated list of absolute file paths matching the given patterns.\n *\n * Handles multiple root directories (deduplicates overlapping roots), exclude\n * patterns, negation patterns embedded in `transformPattern`, and optional\n * dot-file inclusion.\n *\n * @example\n * // Single root with excludes\n * const files = buildComponentFilesList({\n *   transformPattern: 'src/**\\/*.{ts,tsx}',\n *   excludePattern: ['**\\/node_modules\\/**'],\n *   baseDir: '/path/to/project',\n * });\n *\n * @example\n * // Multiple roots (e.g. baseDir + codeDir), dot files included\n * const files = buildComponentFilesList({\n *   transformPattern: config.build.traversePattern,\n *   baseDir: [config.system.baseDir, ...config.content.codeDir],\n *   dot: true,\n * });\n */\nexport const buildComponentFilesList = (\n  config: BuildComponentFilesListOptions\n): string[] => {\n  const {\n    transformPattern,\n    excludePattern = [],\n    baseDir,\n    dot = false,\n  } = config;\n\n  const patterns = normalizeToArray(transformPattern)\n    .filter(\n      (pattern): pattern is string =>\n        typeof pattern === 'string' && !pattern.startsWith('!')\n    )\n    .map(normalize); // Ensure it works with Windows\n\n  const excludePatterns = [\n    ...normalizeToArray(excludePattern),\n    // Treat negation entries in transformPattern as additional excludes\n    ...normalizeToArray(transformPattern)\n      .filter(\n        (pattern): pattern is string =>\n          typeof pattern === 'string' && pattern.startsWith('!')\n      )\n      .map((pattern) => pattern.slice(1)),\n  ]\n    .filter((pattern): pattern is string => typeof pattern === 'string')\n    .map(normalize); // Ensure it works with Windows\n\n  const roots = getDistinctRootDirs(normalizeToArray(baseDir));\n\n  return Array.from(\n    new Set(\n      roots.flatMap((root) =>\n        fg.sync(patterns, {\n          cwd: root,\n          ignore: excludePatterns,\n          absolute: true,\n          dot,\n        })\n      )\n    )\n  );\n};\n\n/**\n * Convenience wrapper that derives all file-list options directly from an\n * `IntlayerConfig` object.\n *\n * Scans `[baseDir, ...codeDir]` using `build.traversePattern`, excludes\n * content declaration file extensions and any `compiler.excludePattern`\n * entries defined in the configuration, and includes dot files.\n */\nexport const buildComponentFilesListFromConfig = (\n  intlayerConfig: IntlayerConfig\n): string[] => {\n  const {\n    build: { traversePattern },\n    system: { baseDir },\n    content: { codeDir, fileExtensions },\n    compiler: { excludePattern },\n  } = intlayerConfig;\n\n  const excludePatterns = [\n    // Exclude content declaration files (e.g. **/*.content.ts)\n    ...fileExtensions.map((ext) => `**/*${ext}`),\n    ...(Array.isArray(excludePattern) ? excludePattern : [excludePattern]),\n  ].filter((p): p is string => typeof p === 'string');\n\n  return buildComponentFilesList({\n    transformPattern: traversePattern,\n    excludePattern: excludePatterns,\n    baseDir: [baseDir, ...codeDir],\n    dot: true,\n  });\n};\n"],"mappings":";;;;;;;AA+BA,MAAM,oBAAuB,UAC3B,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;AAOxC,MAAM,uBAAuB,SAA6B;CACxD,MAAM,aAAa,MAAM,KAAK,IAAI,IAAI,KAAK,KAAK,QAAQ,QAAQ,IAAI,CAAC,CAAC,CAAC;AACvE,YAAW,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,OAAO;AAE9C,QAAO,WAAW,QAAQ,KAAe,QAAQ;AAK/C,MAAI,CAJa,IAAI,MAAM,WAAW;GACpC,MAAM,MAAM,SAAS,QAAQ,IAAI;AACjC,UAAO,CAAC,IAAI,WAAW,KAAK,IAAI,CAAC,WAAW,IAAI,IAAI,QAAQ;IAEjD,CAAE,KAAI,KAAK,IAAI;AAC5B,SAAO;IACN,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BR,MAAa,2BACX,WACa;CACb,MAAM,EACJ,kBACA,iBAAiB,EAAE,EACnB,SACA,MAAM,UACJ;CAEJ,MAAM,WAAW,iBAAiB,iBAAiB,CAChD,QACE,YACC,OAAO,YAAY,YAAY,CAAC,QAAQ,WAAW,IAAI,CAC1D,CACA,IAAI,UAAU;CAEjB,MAAM,kBAAkB,CACtB,GAAG,iBAAiB,eAAe,EAEnC,GAAG,iBAAiB,iBAAiB,CAClC,QACE,YACC,OAAO,YAAY,YAAY,QAAQ,WAAW,IAAI,CACzD,CACA,KAAK,YAAY,QAAQ,MAAM,EAAE,CAAC,CACtC,CACE,QAAQ,YAA+B,OAAO,YAAY,SAAS,CACnE,IAAI,UAAU;CAEjB,MAAM,QAAQ,oBAAoB,iBAAiB,QAAQ,CAAC;AAE5D,QAAO,MAAM,KACX,IAAI,IACF,MAAM,SAAS,SACb,GAAG,KAAK,UAAU;EAChB,KAAK;EACL,QAAQ;EACR,UAAU;EACV;EACD,CAAC,CACH,CACF,CACF;;;;;;;;;;AAWH,MAAa,qCACX,mBACa;CACb,MAAM,EACJ,OAAO,EAAE,mBACT,QAAQ,EAAE,WACV,SAAS,EAAE,SAAS,kBACpB,UAAU,EAAE,qBACV;AAQJ,QAAO,wBAAwB;EAC7B,kBAAkB;EAClB,gBARsB,CAEtB,GAAG,eAAe,KAAK,QAAQ,OAAO,MAAM,EAC5C,GAAI,MAAM,QAAQ,eAAe,GAAG,iBAAiB,CAAC,eAAe,CACtE,CAAC,QAAQ,MAAmB,OAAO,MAAM,SAIT;EAC/B,SAAS,CAAC,SAAS,GAAG,QAAQ;EAC9B,KAAK;EACN,CAAC"}