@intlayer/svelte-compiler 7.3.2-canary.0

package/dist/esm/svelte-intlayer-extract.mjs

@@ -0,0 +1,198 @@
+import { basename, dirname, extname } from "node:path";
+
+//#region src/svelte-intlayer-extract.ts
+/**
+* Attributes that should be extracted for localization
+*/
+const ATTRIBUTES_TO_EXTRACT = [
+	"title",
+	"placeholder",
+	"alt",
+	"aria-label",
+	"label"
+];
+/**
+* Default function to determine if a string should be extracted
+*/
+const defaultShouldExtract = (text) => {
+	const trimmed = text.trim();
+	if (!trimmed) return false;
+	if (!trimmed.includes(" ")) return false;
+	if (!/^[A-Z]/.test(trimmed)) return false;
+	if (trimmed.startsWith("{") || trimmed.startsWith("v-")) return false;
+	return true;
+};
+/**
+* Generate a unique key from text
+*/
+const generateKey = (text, existingKeys) => {
+	let key = text.replace(/\s+/g, " ").replace(/_+/g, " ").replace(/-+/g, " ").replace(/[^a-zA-Z0-9 ]/g, "").trim().split(" ").filter(Boolean).slice(0, 5).map((word, index) => index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+	if (!key) key = "content";
+	if (existingKeys.has(key)) {
+		let i = 1;
+		while (existingKeys.has(`${key}${i}`)) i++;
+		key = `${key}${i}`;
+	}
+	return key;
+};
+/**
+* Extract dictionary key from file path
+*/
+const extractDictionaryKeyFromPath = (filePath) => {
+	let baseName = basename(filePath, extname(filePath));
+	if (baseName === "index") baseName = basename(dirname(filePath));
+	return `comp-${baseName.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase()}`;
+};
+/**
+* Check if a file should be processed based on filesList
+*/
+const shouldProcessFile = (filename, filesList) => {
+	if (!filename) return false;
+	if (!filesList || filesList.length === 0) return true;
+	const normalizedFilename = filename.replace(/\\/g, "/");
+	return filesList.some((f) => {
+		return f.replace(/\\/g, "/") === normalizedFilename;
+	});
+};
+/**
+* Svelte extraction plugin that extracts content and transforms Svelte components to use useIntlayer.
+*
+* This plugin:
+* 1. Scans Svelte files for extractable text (template text, attributes)
+* 2. Auto-injects useIntlayer import and store binding
+* 3. Reports extracted content via onExtract callback (for the compiler to write dictionaries)
+* 4. Replaces extractable strings with content references using Svelte's reactive `$` prefix
+*
+* ## Input
+* ```svelte
+* <h1>Hello World</h1>
+* <p>Welcome to our app</p>
+* ```
+*
+* ## Output
+* ```svelte
+* <script>
+* import { useIntlayer } from 'svelte-intlayer';
+* const content = useIntlayer('hello-world');
+* <\/script>
+* <h1>{$content.helloWorld}</h1>
+* <p>{$content.welcomeToOurApp}</p>
+* ```
+*
+* Note: Svelte uses reactive stores with `$` prefix for automatic subscription.
+* The `useIntlayer` composable returns a Svelte store that can be accessed reactively.
+*/
+const intlayerSvelteExtract = async (code, filename, options = {}) => {
+	const { defaultLocale = "en", packageName = "svelte-intlayer", filesList, shouldExtract = defaultShouldExtract, onExtract } = options;
+	if (!shouldProcessFile(filename, filesList)) return null;
+	if (!filename.endsWith(".svelte")) return null;
+	let MagicString;
+	try {
+		MagicString = (await import("magic-string")).default;
+	} catch {
+		console.warn("Svelte extraction: magic-string not found. Install it to enable Svelte content extraction.");
+		return null;
+	}
+	const magic = new MagicString(code);
+	const extractedContent = {};
+	const existingKeys = /* @__PURE__ */ new Set();
+	const dictionaryKey = extractDictionaryKeyFromPath(filename);
+	const replacements = [];
+	const scriptBlockRegex = /<script[^>]*>[\s\S]*?<\/script>/gi;
+	const styleBlockRegex = /<style[^>]*>[\s\S]*?<\/style>/gi;
+	const skipRanges = [];
+	const scriptMatches = code.matchAll(scriptBlockRegex);
+	for (const match of scriptMatches) if (match.index !== void 0) skipRanges.push({
+		start: match.index,
+		end: match.index + match[0].length
+	});
+	const styleMatches = code.matchAll(styleBlockRegex);
+	for (const match of styleMatches) if (match.index !== void 0) skipRanges.push({
+		start: match.index,
+		end: match.index + match[0].length
+	});
+	skipRanges.sort((a, b) => a.start - b.start);
+	const isInSkipRange = (pos) => {
+		return skipRanges.some((range) => pos >= range.start && pos < range.end);
+	};
+	const textMatches = code.matchAll(/>([^<]+)</g);
+	for (const match of textMatches) {
+		if (match.index === void 0) continue;
+		const textStart = match.index + 1;
+		const text = match[1];
+		const textEnd = textStart + text.length;
+		if (isInSkipRange(textStart)) continue;
+		if (shouldExtract(text)) {
+			const key = generateKey(text, existingKeys);
+			existingKeys.add(key);
+			const normalizedValue = text.replace(/\s+/g, " ").trim();
+			replacements.push({
+				start: textStart,
+				end: textEnd,
+				replacement: `{$content.${key}}`,
+				key,
+				value: normalizedValue
+			});
+		}
+	}
+	for (const attrName of ATTRIBUTES_TO_EXTRACT) {
+		const attrRegex = new RegExp(`(${attrName})=["']([^"']+)["']`, "gi");
+		const attrMatches = code.matchAll(attrRegex);
+		for (const match of attrMatches) {
+			if (match.index === void 0) continue;
+			const attrStart = match.index;
+			const attrEnd = attrStart + match[0].length;
+			const text = match[2];
+			if (isInSkipRange(attrStart)) continue;
+			if (shouldExtract(text)) {
+				const key = generateKey(text, existingKeys);
+				existingKeys.add(key);
+				replacements.push({
+					start: attrStart,
+					end: attrEnd,
+					replacement: `${attrName}={$content.${key}.value}`,
+					key,
+					value: text.trim()
+				});
+			}
+		}
+	}
+	replacements.sort((a, b) => b.start - a.start);
+	for (const { start, end, replacement, key, value } of replacements) {
+		magic.overwrite(start, end, replacement);
+		extractedContent[key] = value;
+	}
+	if (Object.keys(extractedContent).length === 0) return null;
+	const scriptMatch = /<script[^>]*>([\s\S]*?)<\/script>/.exec(code);
+	const scriptContent = scriptMatch ? scriptMatch[1] : "";
+	const hasUseIntlayerImport = /import\s*{[^}]*useIntlayer[^}]*}\s*from\s*['"][^'"]+['"]/.test(scriptContent) || /import\s+useIntlayer\s+from\s*['"][^'"]+['"]/.test(scriptContent);
+	const hasContentDeclaration = /const\s+content\s*=\s*useIntlayer\s*\(/.test(scriptContent);
+	if (hasUseIntlayerImport && hasContentDeclaration) return null;
+	const importStmt = hasUseIntlayerImport ? "" : `import { useIntlayer } from '${packageName}';`;
+	const contentDecl = hasContentDeclaration ? "" : `const content = useIntlayer('${dictionaryKey}');`;
+	const injectionParts = [importStmt, contentDecl].filter(Boolean);
+	if (injectionParts.length === 0) return null;
+	const injection = `\n  ${injectionParts.join("\n  ")}\n`;
+	if (scriptMatch) {
+		const scriptContentStart = scriptMatch.index + scriptMatch[0].indexOf(">") + 1;
+		magic.appendLeft(scriptContentStart, injection);
+	} else magic.prepend(`<script>\n  ${importStmt}\n  ${contentDecl}\n<\/script>\n\n`);
+	if (onExtract) onExtract({
+		dictionaryKey,
+		filePath: filename,
+		content: { ...extractedContent },
+		locale: defaultLocale
+	});
+	return {
+		code: magic.toString(),
+		map: magic.generateMap({
+			source: filename,
+			includeContent: true
+		}),
+		extracted: true
+	};
+};
+
+//#endregion
+export { ATTRIBUTES_TO_EXTRACT, defaultShouldExtract, extractDictionaryKeyFromPath, generateKey, intlayerSvelteExtract, shouldProcessFile };
+//# sourceMappingURL=svelte-intlayer-extract.mjs.map

package/dist/esm/svelte-intlayer-extract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte-intlayer-extract.mjs","names":["MagicString: new (code: string) => MagicStringType","extractedContent: ExtractedContent","replacements: Replacement[]","skipRanges: Array<{ start: number; end: number }>"],"sources":["../../src/svelte-intlayer-extract.ts"],"sourcesContent":["import { basename, dirname, extname } from 'node:path';\n\n/* ────────────────────────────────────────── constants ───────────────────── */\n\n/**\n * Attributes that should be extracted for localization\n */\nexport const ATTRIBUTES_TO_EXTRACT = [\n  'title',\n  'placeholder',\n  'alt',\n  'aria-label',\n  'label',\n];\n\n/* ────────────────────────────────────────── types ───────────────────────── */\n\nexport type ExtractedContent = Record<string, string>;\n\n/**\n * Extracted content result from a file transformation\n */\nexport type ExtractResult = {\n  /** Dictionary key derived from the file path */\n  dictionaryKey: string;\n  /** File path that was processed */\n  filePath: string;\n  /** Extracted content key-value pairs */\n  content: ExtractedContent;\n  /** Default locale used */\n  locale: string;\n};\n\n/**\n * Options for extraction plugins\n */\nexport type ExtractPluginOptions = {\n  /**\n   * The default locale for the extracted content\n   * @default 'en'\n   */\n  defaultLocale?: string;\n  /**\n   * The package to import useIntlayer from\n   * @default 'svelte-intlayer'\n   */\n  packageName?: string;\n  /**\n   * Files list to traverse. If provided, only files in this list will be processed.\n   */\n  filesList?: string[];\n  /**\n   * Custom function to determine if a string should be extracted\n   */\n  shouldExtract?: (text: string) => boolean;\n  /**\n   * Callback function called when content is extracted from a file.\n   * This allows the compiler to capture the extracted content and write it to files.\n   * The dictionary will be updated: new keys added, unused keys removed.\n   */\n  onExtract?: (result: ExtractResult) => void;\n};\n\n/* ────────────────────────────────────────── helpers ─────────────────────── */\n\n/**\n * Default function to determine if a string should be extracted\n */\nexport const defaultShouldExtract = (text: string): boolean => {\n  const trimmed = text.trim();\n  if (!trimmed) return false;\n  // Must contain at least one space (likely a sentence/phrase)\n  if (!trimmed.includes(' ')) return false;\n  // Must start with a capital letter\n  if (!/^[A-Z]/.test(trimmed)) return false;\n  // Filter out template logic identifiers\n  if (trimmed.startsWith('{') || trimmed.startsWith('v-')) return false;\n  return true;\n};\n\n/**\n * Generate a unique key from text\n */\nexport const generateKey = (\n  text: string,\n  existingKeys: Set<string>\n): string => {\n  const maxWords = 5;\n  let key = text\n    .replace(/\\s+/g, ' ')\n    .replace(/_+/g, ' ')\n    .replace(/-+/g, ' ')\n    .replace(/[^a-zA-Z0-9 ]/g, '')\n    .trim()\n    .split(' ')\n    .filter(Boolean)\n    .slice(0, maxWords)\n    .map((word, index) =>\n      index === 0\n        ? word.toLowerCase()\n        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()\n    )\n    .join('');\n\n  if (!key) key = 'content';\n  if (existingKeys.has(key)) {\n    let i = 1;\n    while (existingKeys.has(`${key}${i}`)) i++;\n    key = `${key}${i}`;\n  }\n  return key;\n};\n\n/**\n * Extract dictionary key from file path\n */\nexport const extractDictionaryKeyFromPath = (filePath: string): string => {\n  const ext = extname(filePath);\n  let baseName = basename(filePath, ext);\n\n  if (baseName === 'index') {\n    baseName = basename(dirname(filePath));\n  }\n\n  // Convert to kebab-case\n  const key = baseName\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .replace(/[\\s_]+/g, '-')\n    .toLowerCase();\n\n  return `comp-${key}`;\n};\n\n/**\n * Check if a file should be processed based on filesList\n */\nexport const shouldProcessFile = (\n  filename: string | undefined,\n  filesList?: string[]\n): boolean => {\n  if (!filename) return false;\n  if (!filesList || filesList.length === 0) return true;\n\n  // Normalize paths for comparison (handle potential path separator issues)\n  const normalizedFilename = filename.replace(/\\\\/g, '/');\n  return filesList.some((f) => {\n    const normalizedF = f.replace(/\\\\/g, '/');\n    return normalizedF === normalizedFilename;\n  });\n};\n\n/* ────────────────────────────────────────── MagicString type ────────────── */\n\n// MagicString type for dynamic import\ntype MagicStringType = {\n  overwrite: (start: number, end: number, content: string) => void;\n  appendLeft: (index: number, content: string) => void;\n  prepend: (content: string) => void;\n  toString: () => string;\n  generateMap: (options: {\n    source: string;\n    includeContent: boolean;\n  }) => unknown;\n};\n\n/* ────────────────────────────────────────── plugin ──────────────────────── */\n\n/**\n * Svelte extraction plugin that extracts content and transforms Svelte components to use useIntlayer.\n *\n * This plugin:\n * 1. Scans Svelte files for extractable text (template text, attributes)\n * 2. Auto-injects useIntlayer import and store binding\n * 3. Reports extracted content via onExtract callback (for the compiler to write dictionaries)\n * 4. Replaces extractable strings with content references using Svelte's reactive `$` prefix\n *\n * ## Input\n * ```svelte\n * <h1>Hello World</h1>\n * <p>Welcome to our app</p>\n * ```\n *\n * ## Output\n * ```svelte\n * <script>\n * import { useIntlayer } from 'svelte-intlayer';\n * const content = useIntlayer('hello-world');\n * </script>\n * <h1>{$content.helloWorld}</h1>\n * <p>{$content.welcomeToOurApp}</p>\n * ```\n *\n * Note: Svelte uses reactive stores with `$` prefix for automatic subscription.\n * The `useIntlayer` composable returns a Svelte store that can be accessed reactively.\n */\nexport const intlayerSvelteExtract = async (\n  code: string,\n  filename: string,\n  options: ExtractPluginOptions = {}\n): Promise<{ code: string; map?: unknown; extracted: boolean } | null> => {\n  const {\n    defaultLocale = 'en',\n    packageName = 'svelte-intlayer',\n    filesList,\n    shouldExtract = defaultShouldExtract,\n    onExtract,\n  } = options;\n\n  // Check if file should be processed\n  if (!shouldProcessFile(filename, filesList)) {\n    return null;\n  }\n\n  // Skip non-Svelte files\n  if (!filename.endsWith('.svelte')) {\n    return null;\n  }\n\n  // Dynamic import for MagicString\n  let MagicString: new (code: string) => MagicStringType;\n\n  try {\n    const magicStringModule = await import('magic-string');\n    MagicString = magicStringModule.default;\n  } catch {\n    console.warn(\n      'Svelte extraction: magic-string not found. Install it to enable Svelte content extraction.'\n    );\n    return null;\n  }\n\n  const magic = new MagicString(code);\n  const extractedContent: ExtractedContent = {};\n  const existingKeys = new Set<string>();\n  const dictionaryKey = extractDictionaryKeyFromPath(filename);\n\n  // Collect all replacements first, then apply them in reverse order\n  // This prevents MagicString \"chunk already edited\" errors\n  type Replacement = {\n    start: number;\n    end: number;\n    replacement: string;\n    key: string;\n    value: string;\n  };\n  const replacements: Replacement[] = [];\n\n  // Extract template content (everything outside <script> and <style> tags)\n  // This regex-based approach works with both TypeScript and JavaScript files\n  const scriptBlockRegex = /<script[^>]*>[\\s\\S]*?<\\/script>/gi;\n  const styleBlockRegex = /<style[^>]*>[\\s\\S]*?<\\/style>/gi;\n\n  // Get ranges of script and style blocks to skip\n  const skipRanges: Array<{ start: number; end: number }> = [];\n\n  // Find all script blocks\n  const scriptMatches = code.matchAll(scriptBlockRegex);\n  for (const match of scriptMatches) {\n    if (match.index !== undefined) {\n      skipRanges.push({\n        start: match.index,\n        end: match.index + match[0].length,\n      });\n    }\n  }\n\n  // Find all style blocks\n  const styleMatches = code.matchAll(styleBlockRegex);\n  for (const match of styleMatches) {\n    if (match.index !== undefined) {\n      skipRanges.push({\n        start: match.index,\n        end: match.index + match[0].length,\n      });\n    }\n  }\n\n  // Sort ranges by start position\n  skipRanges.sort((a, b) => a.start - b.start);\n\n  // Function to check if a position is within a skip range\n  const isInSkipRange = (pos: number): boolean => {\n    return skipRanges.some((range) => pos >= range.start && pos < range.end);\n  };\n\n  // Extract text content between HTML tags (but not inside script/style)\n  // Match text that's between > and < (tag content)\n  const textContentRegex = />([^<]+)</g;\n  const textMatches = code.matchAll(textContentRegex);\n  for (const match of textMatches) {\n    if (match.index === undefined) continue;\n\n    const textStart = match.index + 1; // Skip the >\n    const text = match[1];\n    const textEnd = textStart + text.length;\n\n    // Skip if inside script or style block\n    if (isInSkipRange(textStart)) {\n      continue;\n    }\n\n    if (shouldExtract(text)) {\n      const key = generateKey(text, existingKeys);\n      existingKeys.add(key);\n      const normalizedValue = text.replace(/\\s+/g, ' ').trim();\n      // Collect replacement instead of applying immediately\n      replacements.push({\n        start: textStart,\n        end: textEnd,\n        replacement: `{$content.${key}}`,\n        key,\n        value: normalizedValue,\n      });\n    }\n  }\n\n  // Extract localizable attributes (title, placeholder, alt, aria-label, label)\n  for (const attrName of ATTRIBUTES_TO_EXTRACT) {\n    // Match attribute=\"value\" or attribute='value'\n    const attrRegex = new RegExp(`(${attrName})=[\"']([^\"']+)[\"']`, 'gi');\n    const attrMatches = code.matchAll(attrRegex);\n    for (const match of attrMatches) {\n      if (match.index === undefined) continue;\n\n      const attrStart = match.index;\n      const attrEnd = attrStart + match[0].length;\n      const text = match[2];\n\n      // Skip if inside script or style block\n      if (isInSkipRange(attrStart)) {\n        continue;\n      }\n\n      if (shouldExtract(text)) {\n        const key = generateKey(text, existingKeys);\n        existingKeys.add(key);\n        // Collect replacement instead of applying immediately\n        replacements.push({\n          start: attrStart,\n          end: attrEnd,\n          replacement: `${attrName}={$content.${key}.value}`,\n          key,\n          value: text.trim(),\n        });\n      }\n    }\n  }\n\n  // Sort replacements by start position in REVERSE order (end to start)\n  // This ensures earlier edits don't affect the positions of later edits\n  replacements.sort((a, b) => b.start - a.start);\n\n  // Apply all replacements and collect extracted content\n  for (const { start, end, replacement, key, value } of replacements) {\n    magic.overwrite(start, end, replacement);\n    extractedContent[key] = value;\n  }\n\n  // If nothing was extracted, return null\n  if (Object.keys(extractedContent).length === 0) {\n    return null;\n  }\n\n  // Find existing script tag\n  const scriptRegex = /<script[^>]*>([\\s\\S]*?)<\\/script>/;\n  const scriptMatch = scriptRegex.exec(code);\n  const scriptContent = scriptMatch ? scriptMatch[1] : '';\n\n  // Check if useIntlayer is already imported\n  const hasUseIntlayerImport =\n    /import\\s*{[^}]*useIntlayer[^}]*}\\s*from\\s*['\"][^'\"]+['\"]/.test(\n      scriptContent\n    ) || /import\\s+useIntlayer\\s+from\\s*['\"][^'\"]+['\"]/.test(scriptContent);\n\n  // Check if content variable is already declared with useIntlayer\n  const hasContentDeclaration = /const\\s+content\\s*=\\s*useIntlayer\\s*\\(/.test(\n    scriptContent\n  );\n\n  // Skip injection if already using useIntlayer\n  if (hasUseIntlayerImport && hasContentDeclaration) {\n    return null;\n  }\n\n  // Prepare injection statements (only what's missing)\n  const importStmt = hasUseIntlayerImport\n    ? ''\n    : `import { useIntlayer } from '${packageName}';`;\n  const contentDecl = hasContentDeclaration\n    ? ''\n    : `const content = useIntlayer('${dictionaryKey}');`;\n\n  // Build injection string\n  const injectionParts = [importStmt, contentDecl].filter(Boolean);\n  if (injectionParts.length === 0) {\n    return null;\n  }\n  const injection = `\\n  ${injectionParts.join('\\n  ')}\\n`;\n\n  if (scriptMatch) {\n    // Insert at the beginning of script content\n    const scriptContentStart =\n      scriptMatch.index + scriptMatch[0].indexOf('>') + 1;\n    magic.appendLeft(scriptContentStart, injection);\n  } else {\n    // No script block, create one\n    magic.prepend(`<script>\\n  ${importStmt}\\n  ${contentDecl}\\n</script>\\n\\n`);\n  }\n\n  // Call the onExtract callback with extracted content\n  if (onExtract) {\n    const result: ExtractResult = {\n      dictionaryKey,\n      filePath: filename,\n      content: { ...extractedContent },\n      locale: defaultLocale,\n    };\n    onExtract(result);\n  }\n\n  return {\n    code: magic.toString(),\n    map: magic.generateMap({ source: filename, includeContent: true }),\n    extracted: true,\n  };\n};\n"],"mappings":"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"}

package/dist/types/SvelteIntlayerCompiler.d.ts

@@ -0,0 +1,101 @@
+import { GetConfigurationOptions } from "@intlayer/config";
+import { CompilerConfig } from "@intlayer/types";
+
+//#region src/SvelteIntlayerCompiler.d.ts
+
+/**
+ * Mode of the compiler
+ */
+type CompilerMode = 'dev' | 'build';
+/**
+ * Context for hot update handling
+ */
+type HotUpdateContext = {
+  file: string;
+  server: {
+    ws: {
+      send: (message: {
+        type: string;
+      }) => void;
+    };
+    moduleGraph: {
+      getModulesByFile: (file: string) => Set<unknown> | null | undefined;
+      invalidateModule: (module: unknown, seen: Set<unknown>, timestamp: number, isHmr: boolean) => void;
+    };
+  };
+  timestamp: number;
+};
+/**
+ * Transform result from the compiler
+ */
+type TransformResult = {
+  code?: string;
+  map?: unknown;
+} | null;
+/**
+ * Options for initializing the Svelte compiler
+ */
+type SvelteIntlayerCompilerOptions = {
+  /**
+   * Configuration options for getting the intlayer configuration
+   */
+  configOptions?: GetConfigurationOptions;
+  /**
+   * Custom compiler configuration to override defaults
+   */
+  compilerConfig?: Partial<CompilerConfig>;
+};
+/**
+ * Vite plugin object returned by the compiler
+ */
+type SvelteIntlayerVitePlugin = {
+  name: string;
+  enforce: 'pre' | 'post';
+  configResolved: (config: {
+    env?: {
+      DEV?: boolean;
+    };
+    root: string;
+  }) => Promise<void>;
+  buildStart: () => Promise<void>;
+  configureServer: () => Promise<void>;
+  handleHotUpdate: (ctx: HotUpdateContext) => Promise<unknown[] | undefined>;
+  transform: {
+    order: 'pre' | 'post';
+    handler: (code: string, id: string, options?: {
+      ssr?: boolean;
+    }) => Promise<TransformResult>;
+  };
+  apply: (config: unknown, env: {
+    command: string;
+  }) => boolean;
+};
+/**
+ * Create a SvelteIntlayerCompiler - A Vite-compatible compiler plugin for Svelte with Intlayer
+ *
+ * Handles Svelte components with special handling for:
+ * - Script blocks in .svelte files
+ * - TypeScript in Svelte files
+ * - Svelte-specific transformations
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from 'vite';
+ * import { svelte } from '@sveltejs/vite-plugin-svelte';
+ * import { svelteIntlayerCompiler } from '@intlayer/svelte-compiler';
+ *
+ * export default defineConfig({
+ *   plugins: [svelte(), svelteIntlayerCompiler()],
+ * });
+ * ```
+ */
+declare const createSvelteIntlayerCompiler: (options?: SvelteIntlayerCompilerOptions) => SvelteIntlayerVitePlugin;
+/**
+ * Factory function for creating a Vite plugin
+ */
+declare const svelteIntlayerCompiler: (options?: SvelteIntlayerCompilerOptions) => SvelteIntlayerVitePlugin;
+declare const SvelteIntlayerCompiler: (options?: SvelteIntlayerCompilerOptions) => SvelteIntlayerVitePlugin;
+//#endregion
+export { CompilerMode, HotUpdateContext, SvelteIntlayerCompiler, SvelteIntlayerCompilerOptions, SvelteIntlayerVitePlugin, TransformResult, createSvelteIntlayerCompiler, svelteIntlayerCompiler };
+//# sourceMappingURL=SvelteIntlayerCompiler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SvelteIntlayerCompiler.d.ts","names":[],"sources":["../../src/SvelteIntlayerCompiler.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;AAKY,KALA,YAAA,GAKgB,KAAA,GAKc,OAG5B;AAYd;AAQA;;AAS2B,KArCf,gBAAA,GAqCe;EAAR,IAAA,EAAA,MAAA;EAAO,MAAA,EAAA;IAMd,EAAA,EAAA;MAMJ,IAAA,EAAA,CAAA,OAAA,EAAA;QACY,IAAA,EAAA,MAAA;MACK,CAAA,EAAA,GAAA,IAAA;IACA,CAAA;IAAqB,WAAA,EAAA;MAO7B,gBAAA,EAAA,CAAA,IAAA,EAAA,MAAA,EAAA,GAtDyB,GAsDzB,CAAA,OAAA,CAAA,GAAA,IAAA,GAAA,SAAA;MAAR,gBAAA,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,IAAA,EAnDK,GAmDL,CAAA,OAAA,CAAA,EAAA,SAAA,EAAA,MAAA,EAAA,KAAA,EAAA,OAAA,EAAA,GAAA,IAAA;IAAO,CAAA;EAyBH,CAAA;EA+UA,SAAA,EAAA,MAAA;AAOb,CAAA;;;;KAtZY,eAAA;;;;;;;KAQA,6BAAA;;;;kBAIM;;;;mBAKC,QAAQ;;;;;KAMf,wBAAA;;;;;;;;QAMJ;oBACY;yBACK;yBACA,qBAAqB;;;;;UAOrC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;cAyBJ,yCACD,kCACT;;;;cA6UU,mCACD,kCACT;cAKU,mCArVD,kCACT"}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+import { CompilerMode, HotUpdateContext, SvelteIntlayerCompiler, SvelteIntlayerCompilerOptions, SvelteIntlayerVitePlugin, TransformResult, createSvelteIntlayerCompiler, svelteIntlayerCompiler } from "./SvelteIntlayerCompiler.js";
+import { ATTRIBUTES_TO_EXTRACT, ExtractPluginOptions, ExtractResult, ExtractedContent, defaultShouldExtract, extractDictionaryKeyFromPath, generateKey, intlayerSvelteExtract, shouldProcessFile } from "./svelte-intlayer-extract.js";
+export { ATTRIBUTES_TO_EXTRACT, type CompilerMode, type ExtractPluginOptions, type ExtractResult, type ExtractedContent, type HotUpdateContext, SvelteIntlayerCompiler, type SvelteIntlayerCompilerOptions, type SvelteIntlayerVitePlugin, type TransformResult, createSvelteIntlayerCompiler, defaultShouldExtract, extractDictionaryKeyFromPath, generateKey, intlayerSvelteExtract, shouldProcessFile, svelteIntlayerCompiler };

package/dist/types/svelte-intlayer-extract.d.ts

@@ -0,0 +1,100 @@
+//#region src/svelte-intlayer-extract.d.ts
+/**
+ * Attributes that should be extracted for localization
+ */
+declare const ATTRIBUTES_TO_EXTRACT: string[];
+type ExtractedContent = Record<string, string>;
+/**
+ * Extracted content result from a file transformation
+ */
+type ExtractResult = {
+  /** Dictionary key derived from the file path */
+  dictionaryKey: string;
+  /** File path that was processed */
+  filePath: string;
+  /** Extracted content key-value pairs */
+  content: ExtractedContent;
+  /** Default locale used */
+  locale: string;
+};
+/**
+ * Options for extraction plugins
+ */
+type ExtractPluginOptions = {
+  /**
+   * The default locale for the extracted content
+   * @default 'en'
+   */
+  defaultLocale?: string;
+  /**
+   * The package to import useIntlayer from
+   * @default 'svelte-intlayer'
+   */
+  packageName?: string;
+  /**
+   * Files list to traverse. If provided, only files in this list will be processed.
+   */
+  filesList?: string[];
+  /**
+   * Custom function to determine if a string should be extracted
+   */
+  shouldExtract?: (text: string) => boolean;
+  /**
+   * Callback function called when content is extracted from a file.
+   * This allows the compiler to capture the extracted content and write it to files.
+   * The dictionary will be updated: new keys added, unused keys removed.
+   */
+  onExtract?: (result: ExtractResult) => void;
+};
+/**
+ * Default function to determine if a string should be extracted
+ */
+declare const defaultShouldExtract: (text: string) => boolean;
+/**
+ * Generate a unique key from text
+ */
+declare const generateKey: (text: string, existingKeys: Set<string>) => string;
+/**
+ * Extract dictionary key from file path
+ */
+declare const extractDictionaryKeyFromPath: (filePath: string) => string;
+/**
+ * Check if a file should be processed based on filesList
+ */
+declare const shouldProcessFile: (filename: string | undefined, filesList?: string[]) => boolean;
+/**
+ * Svelte extraction plugin that extracts content and transforms Svelte components to use useIntlayer.
+ *
+ * This plugin:
+ * 1. Scans Svelte files for extractable text (template text, attributes)
+ * 2. Auto-injects useIntlayer import and store binding
+ * 3. Reports extracted content via onExtract callback (for the compiler to write dictionaries)
+ * 4. Replaces extractable strings with content references using Svelte's reactive `$` prefix
+ *
+ * ## Input
+ * ```svelte
+ * <h1>Hello World</h1>
+ * <p>Welcome to our app</p>
+ * ```
+ *
+ * ## Output
+ * ```svelte
+ * <script>
+ * import { useIntlayer } from 'svelte-intlayer';
+ * const content = useIntlayer('hello-world');
+ * </script>
+ * <h1>{$content.helloWorld}</h1>
+ * <p>{$content.welcomeToOurApp}</p>
+ * ```
+ *
+ * Note: Svelte uses reactive stores with `$` prefix for automatic subscription.
+ * The `useIntlayer` composable returns a Svelte store that can be accessed reactively.
+ */
+declare const intlayerSvelteExtract: (code: string, filename: string, options?: ExtractPluginOptions) => Promise<{
+  code: string;
+  map?: unknown;
+  extracted: boolean;
+} | null>;
+//#endregion
+export { ATTRIBUTES_TO_EXTRACT, ExtractPluginOptions, ExtractResult, ExtractedContent, defaultShouldExtract, extractDictionaryKeyFromPath, generateKey, intlayerSvelteExtract, shouldProcessFile };
+//# sourceMappingURL=svelte-intlayer-extract.d.ts.map

package/dist/types/svelte-intlayer-extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte-intlayer-extract.d.ts","names":[],"sources":["../../src/svelte-intlayer-extract.ts"],"sourcesContent":[],"mappings":";;AAOA;AAUA;AAKY,cAfC,qBAqBF,EAAA,MAAgB,EAAA;AAQf,KAnBA,gBAAA,GAAmB,MAmBC,CAwBT,MAAA,EAAA,MAAa,CAAA;AAQpC;AAeA;AAiCA;AAoBa,KAlHD,aAAA,GA+HX;EA8CY;;;;;WAvKF;;;;;;;KAQC,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;uBAwBW;;;;;cAQV;;;;cAeA,0CAEG;;;;cA+BH;;;;cAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2DA,kEAGF,yBACR"}

package/package.json

@@ -0,0 +1,123 @@
+{
+  "name": "@intlayer/svelte-compiler",
+  "version": "7.3.2-canary.0",
+  "private": false,
+  "description": "Vite-compatible compiler plugin for Svelte with Intlayer, providing HMR support, file transformation, and optimized dictionary loading for Svelte applications.",
+  "keywords": [
+    "intlayer",
+    "svelte",
+    "vite",
+    "compiler",
+    "i18n",
+    "internationalization",
+    "hmr",
+    "typescript"
+  ],
+  "homepage": "https://intlayer.org",
+  "bugs": {
+    "url": "https://github.com/aymericzip/intlayer/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aymericzip/intlayer.git"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Aymeric PINEAU",
+    "url": "https://github.com/aymericzip"
+  },
+  "contributors": [
+    {
+      "name": "Aymeric Pineau",
+      "email": "ay.pineau@gmail.com",
+      "url": "https://github.com/aymericzip"
+    }
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/esm/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "package.json": [
+        "./package.json"
+      ]
+    }
+  },
+  "bin": {
+    "intlayer": "./dist/cjs/index.cjs"
+  },
+  "files": [
+    "./dist",
+    "./package.json"
+  ],
+  "scripts": {
+    "_prepublish": "cp -f ../../README.md ./README.md",
+    "build": "tsdown --config tsdown.config.ts",
+    "build:ci": "tsdown --config tsdown.config.ts",
+    "clean": "rimraf ./dist .turbo",
+    "dev": "tsdown --config tsdown.config.ts --watch",
+    "format": "biome format . --check",
+    "format:fix": "biome format --write .",
+    "lint": "biome lint .",
+    "lint:fix": "biome lint --write .",
+    "prepublish": "echo prepublish temporally disabled to avoid rewrite readme",
+    "publish": "bun publish || true",
+    "publish:canary": "bun publish --access public --tag canary || true",
+    "publish:latest": "bun publish --access public --tag latest || true",
+    "serve": "webpack serve --config ./webpack.config.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "transpile": "webpack --config ./webpack.config.ts",
+    "typecheck": "tsc --noEmit --project tsconfig.types.json",
+    "watch": "webpack --config ./webpack.config.ts --watch"
+  },
+  "dependencies": {
+    "@babel/core": "7.28.4",
+    "@intlayer/babel": "7.3.2-canary.0",
+    "@intlayer/chokidar": "7.3.2-canary.0",
+    "@intlayer/cli": "7.3.2-canary.0",
+    "@intlayer/config": "7.3.2-canary.0",
+    "@intlayer/dictionaries-entry": "7.3.2-canary.0",
+    "@intlayer/types": "7.3.2-canary.0",
+    "fast-glob": "3.3.3",
+    "magic-string": "^0.30.17"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "@utils/ts-config": "1.0.4",
+    "@utils/ts-config-types": "1.0.4",
+    "@utils/tsdown-config": "1.0.4",
+    "rimraf": "6.1.2",
+    "tsdown": "0.16.6",
+    "typescript": "5.9.3",
+    "vitest": "4.0.13"
+  },
+  "peerDependencies": {
+    "@babel/core": ">=6.0.0",
+    "svelte": ">=4.0.0 || >=5.0.0",
+    "vite": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@babel/core": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=14.18"
+  },
+  "bug": {
+    "url": "https://github.com/aymericzip/intlayer/issues"
+  }
+}