@intlayer/engine 9.0.0-canary.12

package/dist/types/loadDictionaries/logTypeScriptErrors.d.ts

@@ -0,0 +1,7 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/loadDictionaries/logTypeScriptErrors.d.ts
+declare const logTypeScriptErrors: (filePaths: string[], configuration: IntlayerConfig) => Promise<void>;
+//#endregion
+export { logTypeScriptErrors };
+//# sourceMappingURL=logTypeScriptErrors.d.ts.map

package/dist/types/loadDictionaries/logTypeScriptErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logTypeScriptErrors.d.ts","names":[],"sources":["../../../src/loadDictionaries/logTypeScriptErrors.ts"],"mappings":";;;cAIa,mBAAA,GACX,SAAA,YACA,aAAA,EAAe,cAAA,KAAc,OAAA"}

package/dist/types/logConfigDetails.d.ts

@@ -0,0 +1,7 @@
+import { GetConfigurationOptions } from "@intlayer/config/node";
+
+//#region src/logConfigDetails.d.ts
+declare const logConfigDetails: (options?: GetConfigurationOptions) => void;
+//#endregion
+export { logConfigDetails };
+//# sourceMappingURL=logConfigDetails.d.ts.map

package/dist/types/logConfigDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logConfigDetails.d.ts","names":[],"sources":["../../src/logConfigDetails.ts"],"mappings":";;;cAgBa,gBAAA,GAAoB,OAAA,GAAU,uBAAA"}

package/dist/types/prepareIntlayer.d.ts

@@ -0,0 +1,15 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/prepareIntlayer.d.ts
+type PrepareIntlayerOptions = {
+  clean?: boolean;
+  env?: 'prod' | 'dev';
+  format?: ('cjs' | 'esm')[];
+  forceRun?: boolean;
+  cacheTimeoutMs?: number;
+  onIsCached?: () => void | Promise<void>;
+};
+declare const prepareIntlayer: (configuration: IntlayerConfig, options?: PrepareIntlayerOptions) => Promise<void>;
+//#endregion
+export { prepareIntlayer };
+//# sourceMappingURL=prepareIntlayer.d.ts.map

package/dist/types/prepareIntlayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareIntlayer.d.ts","names":[],"sources":["../../src/prepareIntlayer.ts"],"mappings":";;;KAoBK,sBAAA;EACH,KAAA;EACA,GAAA;EACA,MAAA;EACA,QAAA;EACA,cAAA;EACA,UAAA,gBAA0B,OAAA;AAAA;AAAA,cAUf,eAAA,GACX,aAAA,EAAe,cAAA,EACf,OAAA,GAAU,sBAAA,KAAsB,OAAA"}

package/dist/types/reduceDictionaryContent/applyMask.d.ts

@@ -0,0 +1,7 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/reduceDictionaryContent/applyMask.d.ts
+declare const applyMask: (full: Dictionary, mask: any) => Dictionary;
+//#endregion
+export { applyMask };
+//# sourceMappingURL=applyMask.d.ts.map

package/dist/types/reduceDictionaryContent/applyMask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyMask.d.ts","names":[],"sources":["../../../src/reduceDictionaryContent/applyMask.ts"],"mappings":";;;cAEa,SAAA,GAAa,IAAA,EAAM,UAAA,EAAY,IAAA,UAAY,UAAA"}

package/dist/types/reduceDictionaryContent/reduceDictionaryContent.d.ts

@@ -0,0 +1,7 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/reduceDictionaryContent/reduceDictionaryContent.d.ts
+declare const reduceDictionaryContent: (fullDictionary: Dictionary, partialDictionary: Dictionary) => Dictionary;
+//#endregion
+export { reduceDictionaryContent };
+//# sourceMappingURL=reduceDictionaryContent.d.ts.map

package/dist/types/reduceDictionaryContent/reduceDictionaryContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduceDictionaryContent.d.ts","names":[],"sources":["../../../src/reduceDictionaryContent/reduceDictionaryContent.ts"],"mappings":";;;cAIa,uBAAA,GACX,cAAA,EAAgB,UAAA,EAChB,iBAAA,EAAmB,UAAA,KAAU,UAAA"}

package/dist/types/scan/analyzeBundleContent.d.ts

@@ -0,0 +1,16 @@
+import { BundleChunkInput, BundleContentAnalysis } from "./types.js";
+
+//#region src/scan/analyzeBundleContent.d.ts
+/**
+ * Analyze the locale weight of a page's JavaScript bundles.
+ *
+ * @param chunks - The fetched JavaScript chunks (main + lazy).
+ * @param htmlContent - The page HTML, used to estimate rendered content size.
+ * @param currentLocale - The locale currently rendered by the page.
+ * @param totalPageSize - The total transferred bytes measured for the page.
+ * @returns The aggregated {@link BundleContentAnalysis}.
+ */
+declare const analyzeBundleContent: (chunks: BundleChunkInput[], htmlContent: string, currentLocale: string, totalPageSize: number) => BundleContentAnalysis;
+//#endregion
+export { analyzeBundleContent };
+//# sourceMappingURL=analyzeBundleContent.d.ts.map

package/dist/types/scan/analyzeBundleContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeBundleContent.d.ts","names":[],"sources":["../../../src/scan/analyzeBundleContent.ts"],"mappings":";;;;;AA6KA;;;;;;;cAAa,oBAAA,GACX,MAAA,EAAQ,gBAAA,IACR,WAAA,UACA,aAAA,UACA,aAAA,aACC,qBAAA"}

package/dist/types/scan/calculateScore.d.ts

@@ -0,0 +1,65 @@
+//#region src/scan/calculateScore.d.ts
+/**
+ * Mutualized SEO/i18n scoring logic.
+ *
+ * This module is the single source of truth for turning audit/scan events into
+ * a weighted score. It is consumed both by the hosted backend SEO audit
+ * (`apps/backend`) and by the `intlayer scan` CLI command, so it must stay free
+ * of any server-only dependency (no Fastify, no Cheerio, no logger coupling).
+ */
+/** Accumulated score across all checks that ran. */
+type Score = {
+  /** Sum of points obtained (success = full, warning = half, error = none). */score: number; /** Maximum achievable points for the checks that ran. */
+  totalScore: number;
+};
+/**
+ * Minimal shape of an event needed to contribute to the score.
+ *
+ * The `type` is the check identifier. URL-scoped checks are suffixed with the
+ * URL using a backslash separator (e.g. `url_htmlLang\https://example.com`), so
+ * only the part before the first backslash is used to look up the weight.
+ */
+type ScorableEvent = {
+  type?: string;
+  status?: string;
+};
+/** Weight (in points) of every scorable check. */
+declare const scoreRecord: {
+  readonly robots_robotsPresent: 10;
+  readonly robots_noLocalizedUrlsForgotten: 8;
+  readonly sitemap_sitemapPresent: 10;
+  readonly sitemap_noLocalizedUrlsForgotten: 9;
+  readonly sitemap_hasAlternates: 8;
+  readonly sitemap_hasXDefault: 7;
+  readonly url_htmlLang: 9;
+  readonly url_htmlDir: 3;
+  readonly url_hasCanonical: 10;
+  readonly url_hreflang: 9;
+  readonly url_hasLocalizedLinks: 8;
+  readonly url_hasXDefault: 7;
+  readonly url_allAnchorsLocalized: 6;
+  readonly url_currentLocale: 3;
+  readonly url_unusedBundleContent: 8;
+};
+/** Identifier of a scorable check (without the URL suffix). */
+type ScoreCheckType = keyof typeof scoreRecord;
+/**
+ * Apply a single event to the running score, returning a new {@link Score}.
+ * Unknown check types are ignored so the function is safe to call on every
+ * emitted event.
+ *
+ * @param score - The current accumulated score.
+ * @param event - The event to fold into the score.
+ * @returns A new score with the event applied.
+ */
+declare const mutateScore: (score: Score, event: ScorableEvent) => Score;
+/**
+ * Convert a raw {@link Score} into a 0–100 percentage.
+ *
+ * @param score - The accumulated score.
+ * @returns The rounded percentage, or 0 when no check ran.
+ */
+declare const toScorePercent: (score: Score) => number;
+//#endregion
+export { ScorableEvent, Score, ScoreCheckType, mutateScore, scoreRecord, toScorePercent };
+//# sourceMappingURL=calculateScore.d.ts.map

package/dist/types/scan/calculateScore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateScore.d.ts","names":[],"sources":["../../../src/scan/calculateScore.ts"],"mappings":";;AAUA;;;;;AAcA;;;KAdY,KAAA;EAgBJ,6EAdN,KAAA,UA8CQ;EA5CR,UAAA;AAAA;;;;;;;;KAUU,aAAA;EACV,IAAA;EACA,MAAA;AAAA;;cAgBW,WAAA;EAAA;;;;;;;;;;;;;;;;;KAmBD,cAAA,gBAA8B,WAAA;;;;;;;AAoC1C;;;cAzBa,WAAA,GAAe,KAAA,EAAO,KAAA,EAAO,KAAA,EAAO,aAAA,KAAgB,KAAA;;;;;;;cAyBpD,cAAA,GAAkB,KAAA,EAAO,KAAA"}

package/dist/types/scan/checks.d.ts

@@ -0,0 +1,38 @@
+import { BundleChunkInput, BundleContentAnalysis, ScanEvent } from "./types.js";
+import { Anchor } from "./parseHtml.js";
+
+//#region src/scan/checks.d.ts
+/** Format a byte count as a human-readable size. */
+declare const formatSize: (bytes: number) => string;
+/**
+ * Check the `<html>` element attributes (`lang`, `dir`) and the resulting
+ * current-locale signal. Returns the detected language tag.
+ */
+declare const checkHtmlAttributes: (html: string, targetUrl: string, events: ScanEvent[]) => {
+  langTag: string | undefined;
+};
+/** Check the presence of a canonical link. */
+declare const checkCanonical: (html: string, targetUrl: string, events: ScanEvent[]) => void;
+/**
+ * Check the page's hreflang structure and collect discovered locales into
+ * `localesSet`.
+ */
+declare const checkLinguisticStructure: (html: string, targetUrl: string, localesSet: Set<string>, events: ScanEvent[]) => void;
+/**
+ * Check whether internal links carry a locale segment, mirroring the hosted
+ * audit's URL-structure analysis but operating on parsed anchors instead of a
+ * live DOM.
+ */
+declare const checkUrlStructure: (anchors: Anchor[], origin: string, targetUrl: string, events: ScanEvent[]) => void;
+/**
+ * Analyze the JavaScript bundles for unused locale content and emit the
+ * corresponding event. Returns the analysis so callers can report on it.
+ */
+declare const checkBundleContent: (chunks: BundleChunkInput[], html: string, currentLocale: string | undefined, targetUrl: string, totalPageSize: number, events: ScanEvent[]) => BundleContentAnalysis | undefined;
+/** Fetch and check `robots.txt`, emitting robots-related events. */
+declare const checkRobots: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+/** Fetch and check `sitemap.xml`, emitting sitemap-related events. */
+declare const checkSitemap: (origin: string, discoveredLocales: Set<string>, userAgent: string, events: ScanEvent[]) => Promise<void>;
+//#endregion
+export { checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure, formatSize };
+//# sourceMappingURL=checks.d.ts.map

package/dist/types/scan/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","names":[],"sources":["../../../src/scan/checks.ts"],"mappings":";;;;;cAgBa,UAAA,GAAc,KAAA;AAA3B;;;;AAAA,cAUa,mBAAA,GACX,IAAA,UACA,SAAA,UACA,MAAA,EAAQ,SAAA;EACL,OAAA;AAAA;;cAmCQ,cAAA,GACX,IAAA,UACA,SAAA,UACA,MAAA,EAAQ,SAAA;;;;;cAcG,wBAAA,GACX,IAAA,UACA,SAAA,UACA,UAAA,EAAY,GAAA,UACZ,MAAA,EAAQ,SAAA;;;AArBV;;;cA6Da,iBAAA,GACX,OAAA,EAAS,MAAA,IACT,MAAA,UACA,SAAA,UACA,MAAA,EAAQ,SAAA;;;;;cAwEG,kBAAA,GACX,MAAA,EAAQ,gBAAA,IACR,IAAA,UACA,aAAA,sBACA,SAAA,UACA,aAAA,UACA,MAAA,EAAQ,SAAA,OACP,qBAAA;;cA0CU,WAAA,GACX,MAAA,UACA,iBAAA,EAAmB,GAAA,UACnB,SAAA,UACA,MAAA,EAAQ,SAAA,OACP,OAAA;;cA0DU,YAAA,GACX,MAAA,UACA,iBAAA,EAAmB,GAAA,UACnB,SAAA,UACA,MAAA,EAAQ,SAAA,OACP,OAAA"}

package/dist/types/scan/index.d.ts

@@ -0,0 +1,7 @@
+import { ScorableEvent, Score, ScoreCheckType, mutateScore, scoreRecord, toScorePercent } from "./calculateScore.js";
+import { BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult } from "./types.js";
+import { analyzeBundleContent } from "./analyzeBundleContent.js";
+import { Anchor, HreflangLink, byteLength, extractAnchors, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractScriptUrls, extractTitle, extractVisibleTextStrings, hasCanonical } from "./parseHtml.js";
+import { checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure, formatSize } from "./checks.js";
+import { scanWebsite } from "./scanWebsite.js";
+export { Anchor, BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, HreflangLink, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult, ScorableEvent, Score, ScoreCheckType, analyzeBundleContent, byteLength, checkBundleContent, checkCanonical, checkHtmlAttributes, checkLinguisticStructure, checkRobots, checkSitemap, checkUrlStructure, extractAnchors, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractScriptUrls, extractTitle, extractVisibleTextStrings, formatSize, hasCanonical, mutateScore, scanWebsite, scoreRecord, toScorePercent };

package/dist/types/scan/parseHtml.d.ts

@@ -0,0 +1,54 @@
+//#region src/scan/parseHtml.d.ts
+/**
+ * Tiny dependency-free HTML extraction helpers.
+ *
+ * The hosted backend audit relies on Cheerio + a real browser, but the CLI scan
+ * must stay dependency-light. These regex-based helpers cover the handful of
+ * head/anchor signals the score needs. They are intentionally forgiving: when a
+ * tag can't be parsed it is simply skipped rather than throwing.
+ */
+/** Compute the UTF-8 byte length of a string in both Node and browser builds. */
+declare const byteLength: (text: string) => number;
+/** Extract the `lang` attribute of the `<html>` element, if present. */
+declare const extractHtmlLang: (html: string) => string | undefined;
+/** Extract the `dir` attribute of the `<html>` element, if present. */
+declare const extractHtmlDir: (html: string) => string | undefined;
+/** Extract the document `<title>` text. */
+declare const extractTitle: (html: string) => string;
+/** Extract the `<meta name="description">` content. */
+declare const extractMetaDescription: (html: string) => string;
+/** Extract the `<meta property="og:image">` content. */
+declare const extractOgImage: (html: string) => string | undefined;
+/** Whether a `<link rel="canonical">` element is present. */
+declare const hasCanonical: (html: string) => boolean;
+/** A parsed `<link rel="alternate" hreflang>` element. */
+type HreflangLink = {
+  hreflang: string;
+  href: string;
+};
+/** Extract every `<link rel="alternate" hreflang="…" href="…">` element. */
+declare const extractHreflangs: (html: string) => HreflangLink[];
+/**
+ * Extract every eagerly-loaded script URL: `<script src>`,
+ * `<link rel="modulepreload">` and `<link rel="preload" as="script">`.
+ *
+ * @param html - The raw HTML document.
+ * @param baseUrl - Base URL used to resolve relative script URLs.
+ * @returns Absolute, de-duplicated script URLs.
+ */
+declare const extractScriptUrls: (html: string, baseUrl: string) => string[];
+/** A parsed `<a href>` anchor. */
+type Anchor = {
+  href: string;
+  text: string;
+};
+/** Extract every `<a href="…">text</a>` anchor from the document. */
+declare const extractAnchors: (html: string) => Anchor[];
+/**
+ * Extract visible text snippets from an HTML document (scripts, styles and
+ * tags stripped). Used to approximate the rendered content size without a DOM.
+ */
+declare const extractVisibleTextStrings: (html: string) => string[];
+//#endregion
+export { Anchor, HreflangLink, byteLength, extractAnchors, extractHreflangs, extractHtmlDir, extractHtmlLang, extractMetaDescription, extractOgImage, extractScriptUrls, extractTitle, extractVisibleTextStrings, hasCanonical };
+//# sourceMappingURL=parseHtml.d.ts.map

package/dist/types/scan/parseHtml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseHtml.d.ts","names":[],"sources":["../../../src/scan/parseHtml.ts"],"mappings":";;AAUA;;;;;AAkBA;;;cAlBa,UAAA,GAAc,IAAA;;cAkBd,eAAA,GAAmB,IAAA;;cAMnB,cAAA,GAAkB,IAAA;;cAMlB,YAAA,GAAgB,IAAA;AAA7B;AAAA,cAMa,sBAAA,GAA0B,IAAA;;cAW1B,cAAA,GAAkB,IAAA;;cAWlB,YAAA,GAAgB,IAAA;;KAMjB,YAAA;EAAiB,QAAA;EAAkB,IAAA;AAAA;;cAGlC,gBAAA,GAAoB,IAAA,aAAe,YAAA;;;AAThD;;;;;AAMA;cAuBa,iBAAA,GAAqB,IAAA,UAAc,OAAA;;KA4BpC,MAAA;EAAW,IAAA;EAAc,IAAA;AAAA;;cAGxB,cAAA,GAAkB,IAAA,aAAe,MAAA;;AA/B9C;;;cAqDa,yBAAA,GAA6B,IAAA"}

package/dist/types/scan/scanWebsite.d.ts

@@ -0,0 +1,18 @@
+import { ScanOptions, ScanResult } from "./types.js";
+
+//#region src/scan/scanWebsite.d.ts
+/**
+ * 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.
+ */
+declare const scanWebsite: (targetUrl: string, options?: ScanOptions) => Promise<ScanResult>;
+//#endregion
+export { scanWebsite };
+//# sourceMappingURL=scanWebsite.d.ts.map

package/dist/types/scan/scanWebsite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanWebsite.d.ts","names":[],"sources":["../../../src/scan/scanWebsite.ts"],"mappings":";;;;;AAmNA;;;;;;;;;cAAa,WAAA,GACX,SAAA,UACA,OAAA,GAAS,WAAA,KACR,OAAA,CAAQ,UAAA"}

package/dist/types/scan/types.d.ts

@@ -0,0 +1,76 @@
+import { Score } from "./calculateScore.js";
+
+//#region src/scan/types.d.ts
+/** Status of an individual scan check. */
+type ScanCheckStatus = 'success' | 'warning' | 'error';
+/** Per-status human-readable details attached to a {@link ScanEvent}. */
+type ScanEventDetails = {
+  success?: unknown;
+  warning?: unknown;
+  error?: unknown;
+};
+/**
+ * A single check produced while scanning a page. The `type` matches a key of
+ * the score table (optionally suffixed with the URL for URL-scoped checks).
+ */
+type ScanEvent = {
+  type: string;
+  status: ScanCheckStatus;
+  details?: ScanEventDetails;
+};
+/** How the scan was performed. */
+type ScanMode = 'basic' | 'deep';
+/** A single JavaScript chunk fetched while scanning. */
+type BundleChunkInput = {
+  url: string; /** Whether the chunk is eagerly loaded on the initial page load. */
+  isMainBundle: boolean;
+  content: string;
+};
+/** Locale-weight analysis of a single bundle chunk. */
+type ChunkAnalysis = {
+  url: string;
+  fileSize: number;
+  totalLocaleSize: number;
+  unusedLocaleSize: number;
+  usedLocaleSize: number;
+  dictionariesFound: number; /** `unusedLocaleSize / totalLocaleSize`, rounded to a percentage. */
+  unusedPercent: number;
+};
+/** Aggregated locale-weight analysis across every fetched chunk. */
+type BundleContentAnalysis = {
+  currentLocale: string;
+  totalPageSize: number;
+  renderedContentSize: number; /** `renderedContentSize` + all locale content. */
+  contentSize: number; /** All locale strings (used + unused, main + lazy). */
+  totalLocaleSize: number; /** All unused locale strings (main + lazy). */
+  totalUnusedLocaleSize: number; /** `totalUnusedLocaleSize / totalLocaleSize`, rounded to a percentage. */
+  unusedPercentOfLocale: number;
+  mainBundleChunks: ChunkAnalysis[];
+  lazyBundleChunks: ChunkAnalysis[];
+};
+/** Options controlling how a website is scanned. */
+type ScanOptions = {
+  /**
+   * Attempt a deeper, render-based scan using a locally installed `puppeteer`.
+   * When `puppeteer` is not installed, the scan transparently falls back to the
+   * basic fetch-based mode. Defaults to `true`.
+   */
+  deep?: boolean; /** Override the request timeout in milliseconds. Defaults to 30000. */
+  timeoutMs?: number; /** Override the User-Agent used for every request. */
+  userAgent?: string;
+};
+/** Result of scanning a single page. */
+type ScanResult = {
+  url: string; /** Whether the scan ran in `basic` or `deep` mode. */
+  mode: ScanMode; /** Total transferred bytes measured for the page. */
+  totalPageSize: number; /** Bytes of the initial HTML document. */
+  htmlSize: number; /** Overall score as a 0–100 percentage. */
+  score: number; /** Raw accumulated score (obtained / total points). */
+  rawScore: Score; /** Every check produced during the scan. */
+  events: ScanEvent[]; /** Locales discovered on the page (from `lang` and `hreflang`). */
+  locales: string[]; /** Locale-weight breakdown of the bundles, when computable. */
+  bundle?: BundleContentAnalysis;
+};
+//#endregion
+export { BundleChunkInput, BundleContentAnalysis, ChunkAnalysis, ScanCheckStatus, ScanEvent, ScanEventDetails, ScanMode, ScanOptions, ScanResult };
+//# sourceMappingURL=types.d.ts.map

package/dist/types/scan/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/scan/types.ts"],"mappings":";;;;KAGY,eAAA;AAAZ;AAAA,KAGY,gBAAA;EACV,OAAA;EACA,OAAA;EACA,KAAA;AAAA;;;;;KAOU,SAAA;EACV,IAAA;EACA,MAAA,EAAQ,eAAA;EACR,OAAA,GAAU,gBAAA;AAAA;;KAIA,QAAA;;KAGA,gBAAA;EACV,GAAA,UATQ;EAWR,YAAA;EACA,OAAA;AAAA;;KAIU,aAAA;EACV,GAAA;EACA,QAAA;EACA,eAAA;EACA,gBAAA;EACA,cAAA;EACA,iBAAA;EAEA,aAAA;AAAA;;KAIU,qBAAA;EACV,aAAA;EACA,aAAA;EACA,mBAAA,UAfuB;EAiBvB,WAAA,UAjBuB;EAmBvB,eAAA,UAjBA;EAmBA,qBAAA,UAjBA;EAmBA,qBAAA;EACA,gBAAA,EAAkB,aAAA;EAClB,gBAAA,EAAkB,aAAA;AAAA;;KAIR,WAAA;EAjBqB;;;;;EAuB/B,IAAA,YAlBA;EAoBA,SAAA,WAhBA;EAkBA,SAAA;AAAA;;KAIU,UAAA;EACV,GAAA,UAnB+B;EAqB/B,IAAA,EAAM,QAAA,EAjBI;EAmBV,aAAA;EAEA,QAAA,UAfA;EAiBA,KAAA,UAbA;EAeA,QAAA,EAAU,KAAA,EAfD;EAiBT,MAAA,EAAQ,SAAA,IAbY;EAepB,OAAA,YAZM;EAcN,MAAA,GAAS,qBAAA;AAAA"}

package/dist/types/utils/autoDecorateContent.d.ts

@@ -0,0 +1,13 @@
+//#region src/utils/autoDecorateContent.d.ts
+type AutoTransformationOptions = {
+  markdown?: boolean;
+  html?: boolean;
+  insertion?: boolean;
+};
+/**
+ * Automatically decorate content strings with md() or insert() if they match
+ */
+declare const autoDecorateContent: (content: any, options?: boolean | AutoTransformationOptions) => any;
+//#endregion
+export { autoDecorateContent };
+//# sourceMappingURL=autoDecorateContent.d.ts.map

package/dist/types/utils/autoDecorateContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoDecorateContent.d.ts","names":[],"sources":["../../../src/utils/autoDecorateContent.ts"],"mappings":";KAwEK,yBAAA;EACH,QAAA;EACA,IAAA;EACA,SAAA;AAAA;;;;cAMW,mBAAA,GACX,OAAA,OACA,OAAA,aAAmB,yBAAA"}

package/dist/types/utils/buildComponentFilesList.d.ts

@@ -0,0 +1,28 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/utils/buildComponentFilesList.d.ts
+/**
+ * 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);
+ */
+declare const buildComponentFilesList: (config: IntlayerConfig, excludePattern?: string[]) => string[];
+//#endregion
+export { buildComponentFilesList };
+//# sourceMappingURL=buildComponentFilesList.d.ts.map

package/dist/types/utils/buildComponentFilesList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildComponentFilesList.d.ts","names":[],"sources":["../../../src/utils/buildComponentFilesList.ts"],"mappings":";;;;;AAqEA;;;;;;;;;;;;;;;;;;;cAAa,uBAAA,GACX,MAAA,EAAQ,cAAA,EACR,cAAA"}

package/dist/types/utils/buildFilesList.d.ts

@@ -0,0 +1,62 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/utils/buildFilesList.d.ts
+/**
+ * Options for building the files list
+ */
+type BuildComponentFilesListOptions = {
+  /**
+   * Glob patterns to match files
+   */
+  transformPattern: string | string[];
+  /**
+   * Glob patterns to exclude files
+   */
+  excludePattern?: string | string[];
+  /**
+   * Base directory (or directories) for file resolution.
+   * When multiple directories are provided, subdirectories of others are
+   * automatically deduplicated so files are never scanned twice.
+   */
+  baseDir: string | string[];
+  /**
+   * Whether to include dot-prefixed files and directories (default: false)
+   */
+  dot?: boolean;
+};
+/**
+ * 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,
+ * });
+ */
+declare const buildComponentFilesList: (config: BuildComponentFilesListOptions) => string[];
+/**
+ * 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.
+ */
+declare const buildComponentFilesListFromConfig: (intlayerConfig: IntlayerConfig) => string[];
+//#endregion
+export { BuildComponentFilesListOptions, buildComponentFilesList, buildComponentFilesListFromConfig };
+//# sourceMappingURL=buildFilesList.d.ts.map

package/dist/types/utils/buildFilesList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildFilesList.d.ts","names":[],"sources":["../../../src/utils/buildFilesList.ts"],"mappings":";;;;;AAOA;KAAY,8BAAA;;;;EAIV,gBAAA;EAUA;;;EANA,cAAA;EA6DW;;;;;EAvDX,OAAA;EAmID;;;EA/HC,GAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;cAmDW,uBAAA,GACX,MAAA,EAAQ,8BAAA;;;;;;;;;cAqDG,iCAAA,GACX,cAAA,EAAgB,cAAA"}

package/dist/types/utils/chunkJSON.d.ts

@@ -0,0 +1,56 @@
+//#region src/utils/chunkJSON.d.ts
+/**
+ * Split & reassemble JSON by character budget.
+ * - Measures serialized size using JSON.stringify(..).length (characters).
+ * - Ensures each chunk is itself valid JSON.
+ * - Very large strings are split into safe pieces using getChunk and re-concatenated on assemble.
+ * - Protects against circular structures (JSON can't serialize those anyway).
+ */
+type JSONPrimitive = string | number | boolean | null;
+type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+type JSONObject = {
+  [k: string]: JSONValue;
+};
+type JSONArray = JSONValue[];
+type Path = Array<string | number>;
+type SetPatch = {
+  op: 'set';
+  path: Path;
+  value: JSONValue;
+};
+type StrAppendPatch = {
+  op: 'str-append';
+  path: Path;
+  value: string;
+  index: number;
+  total: number;
+};
+type Patch = SetPatch | StrAppendPatch;
+type RootType = 'object' | 'array';
+type JsonChunk = {
+  schemaVersion: 1;
+  index: number;
+  total: number;
+  rootType: RootType;
+  checksum: string;
+  entries: Patch[];
+};
+/**
+ * Split JSON into chunks constrained by character count of serialized chunk.
+ */
+declare const chunkJSON: (value: JSONObject | JSONArray, maxChars: number) => JsonChunk[];
+/**
+ * Reassemble JSON from chunks.
+ * - Validates checksums and indices.
+ * - Applies 'set' patches and merges string pieces from 'str-append'.
+ */
+/**
+ * Reconstruct content from a single chunk without validation.
+ * Useful for processing individual chunks in a pipeline where you don't have all chunks yet.
+ * Note: This will only reconstruct the partial content contained in this chunk.
+ */
+declare const reconstructFromSingleChunk: (chunk: JsonChunk) => JSONObject | JSONArray;
+declare const assembleJSON: (chunks: JsonChunk[]) => JSONObject | JSONArray;
+//#endregion
+export { JSONObject, JsonChunk, assembleJSON, chunkJSON, reconstructFromSingleChunk };
+//# sourceMappingURL=chunkJSON.d.ts.map

package/dist/types/utils/chunkJSON.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkJSON.d.ts","names":[],"sources":["../../../src/utils/chunkJSON.ts"],"mappings":";;;;;;;AAUkB;KAAb,aAAA;AAAA,KACA,SAAA,GAAY,aAAA,GAAgB,UAAA,GAAa,SAAA;AAAA,KAElC,UAAA;EAAA,CACT,CAAA,WAAY,SAAA;AAAA;AAAA,KAGV,SAAA,GAAY,SAAA;AAAA,KAEZ,IAAA,GAAO,KAAA;AAAA,KAEP,QAAA;EAAa,EAAA;EAAW,IAAA,EAAM,IAAA;EAAM,KAAA,EAAO,SAAA;AAAA;AAAA,KAC3C,cAAA;EACH,EAAA;EACA,IAAA,EAAM,IAAA;EACN,KAAA;EACA,KAAA;EACA,KAAA;AAAA;AAAA,KAEG,KAAA,GAAQ,QAAA,GAAW,cAAA;AAAA,KAEnB,QAAA;AAAA,KAEO,SAAA;EACV,aAAA;EACA,KAAA;EACA,KAAA;EACA,QAAA,EAAU,QAAA;EACV,QAAA;EACA,OAAA,EAAS,KAAA;AAAA;;;;cAiME,SAAA,GACX,KAAA,EAAO,UAAA,GAAa,SAAA,EACpB,QAAA,aACC,SAAA;;;;;;AAtNsD;;;;;AAAA,cA4U5C,0BAAA,GACX,KAAA,EAAO,SAAA,KACN,UAAA,GAAa,SAAA;AAAA,cAiGH,YAAA,GAAgB,MAAA,EAAQ,SAAA,OAAc,UAAA,GAAa,SAAA"}

package/dist/types/utils/formatter.d.ts

@@ -0,0 +1,9 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { ANSIColorsType } from "@intlayer/config/logger";
+
+//#region src/utils/formatter.d.ts
+declare const formatPath: (path: string | string[], color?: ANSIColorsType | false) => string;
+declare const formatLocale: (locale: LocalesValues | LocalesValues[], color?: ANSIColorsType | false) => string;
+//#endregion
+export { formatLocale, formatPath };
+//# sourceMappingURL=formatter.d.ts.map

package/dist/types/utils/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","names":[],"sources":["../../../src/utils/formatter.ts"],"mappings":";;;;cAYa,UAAA,GACX,IAAA,qBACA,KAAA,GAAQ,cAAA;AAAA,cAYG,YAAA,GACX,MAAA,EAAQ,aAAA,GAAgB,aAAA,IACxB,KAAA,GAAO,cAAA"}

package/dist/types/utils/getChunk.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/getChunk.d.ts
+type TrunkOptions = {
+  lineStart?: number;
+  lineLength?: number;
+  charStart?: number;
+  charLength?: number;
+};
+declare const getChunk: (text: string, options?: TrunkOptions) => string;
+//#endregion
+export { getChunk };
+//# sourceMappingURL=getChunk.d.ts.map

package/dist/types/utils/getChunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getChunk.d.ts","names":[],"sources":["../../../src/utils/getChunk.ts"],"mappings":";KAEK,YAAA;EACH,SAAA;EACA,UAAA;EACA,SAAA;EACA,UAAA;AAAA;AAAA,cAGW,QAAA,GAAY,IAAA,UAAc,OAAA,GAAS,YAAA"}

package/dist/types/utils/getContentExtension.d.ts

@@ -0,0 +1,15 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+
+//#region src/utils/getContentExtension.d.ts
+/**
+ * Generates the .content file extension based on the desired format
+ * and the project's fileExtensions configuration.
+ *
+ * Example:
+ * format 'ts' -> '.content.ts'
+ * format 'esm' -> '.content.js' (if matching .content.js is found in config)
+ */
+declare const getContentExtension: (format: "ts" | "esm" | "cjs" | "json" | "jsonc" | "json5" | (string & {}), configuration: IntlayerConfig) => string;
+//#endregion
+export { getContentExtension };
+//# sourceMappingURL=getContentExtension.d.ts.map

package/dist/types/utils/getContentExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getContentExtension.d.ts","names":[],"sources":["../../../src/utils/getContentExtension.ts"],"mappings":";;;;;AAUA;;;;;;cAAa,mBAAA,GACX,MAAA,qEACA,aAAA,EAAe,cAAA"}

package/dist/types/utils/getFormatFromExtension.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/getFormatFromExtension.d.ts
+type Format = 'ts' | 'cjs' | 'esm' | 'json' | 'jsonc' | 'json5' | 'md' | 'yaml';
+type Extension = '.ts' | '.tsx' | '.js' | '.jsx' | '.cjs' | '.cjsx' | '.mjs' | '.mjsx' | '.json' | '.jsonc' | '.json5' | '.md' | '.mdx' | '.yaml' | '.yml';
+declare const getFormatFromExtension: (extension: Extension | (string & {})) => Format;
+declare const getExtensionFromFormat: (format: Format | (string & {})) => Extension;
+//#endregion
+export { Extension, Format, getExtensionFromFormat, getFormatFromExtension };
+//# sourceMappingURL=getFormatFromExtension.d.ts.map

package/dist/types/utils/getFormatFromExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFormatFromExtension.d.ts","names":[],"sources":["../../../src/utils/getFormatFromExtension.ts"],"mappings":";KAAY,MAAA;AAAA,KAUA,SAAA;AAAA,cAiBC,sBAAA,GACX,SAAA,EAAW,SAAA,qBACV,MAAA;AAAA,cA4BU,sBAAA,GACX,MAAA,EAAQ,MAAA,qBACP,SAAA"}

package/dist/types/utils/getPathHash.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/getPathHash.d.ts
+/**
+ * Fast hashing using cyrb53 algorithm for small unique strings with low collisions risk
+ */
+declare const getPathHash: (filePath: string) => string;
+//#endregion
+export { getPathHash };
+//# sourceMappingURL=getPathHash.d.ts.map

package/dist/types/utils/getPathHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPathHash.d.ts","names":[],"sources":["../../../src/utils/getPathHash.ts"],"mappings":";;AAGA;;cAAa,WAAA,GAAe,QAAA"}