@intlayer/vue-compiler 8.6.10 → 8.7.0-canary.0

package/dist/cjs/extractVueFieldUsage.cjs

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let _vue_compiler_sfc = require("@vue/compiler-sfc");
+_vue_compiler_sfc = require_runtime.__toESM(_vue_compiler_sfc);
+
+//#region src/extractVueFieldUsage.ts
+/**
+* Extracts intlayer dictionary field usage from a Vue SFC for a set of
+* plain variable bindings (i.e. `const content = useIntlayer('key')`).
+*
+* Two access patterns are recognised:
+*
+*   1. `varName.value.fieldName` in script blocks
+*      Vue's `useIntlayer` returns a reactive `Ref<Content>`, so fields are
+*      accessed one level deeper via `.value`.
+*
+*   2. `varName.fieldName` in the template block
+*      Inside `<template>`, Vue automatically unwraps top-level refs, so
+*      fields are accessed directly without `.value`.
+*
+* The template block is extracted via `@vue/compiler-sfc` so that nested
+* `<template v-for>` / `<template v-if>` tags do not confuse the parser.
+* Falls back to a greedy regex when the package is unavailable.
+*/
+/** Escapes special regex characters in a string used as a regex literal. */
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Splits a Vue SFC source string into its script and template regions.
+*
+* Uses `@vue/compiler-sfc` to get exact character offsets so that nested
+* `<template>` tags (used by Vue directives like `v-for` / `v-if`) never
+* cause the template region to be mis-identified.
+*/
+const splitVueSfc = (code) => {
+	try {
+		const { descriptor } = _vue_compiler_sfc.default.parse(code);
+		const templateSource = descriptor.template?.content ?? "";
+		const scriptParts = [];
+		if (descriptor.script?.content) scriptParts.push(descriptor.script.content);
+		if (descriptor.scriptSetup?.content) scriptParts.push(descriptor.scriptSetup.content);
+		return {
+			scriptSource: scriptParts.join("\n"),
+			templateSource
+		};
+	} catch {
+		const templateMatch = /<template(?:[^>]*)>([\s\S]*)<\/template>/i.exec(code);
+		const templateSource = templateMatch ? templateMatch[1] : "";
+		return {
+			scriptSource: code.replace(/<template[\s\S]*<\/template>/gi, ""),
+			templateSource
+		};
+	}
+};
+/**
+* Analyzes a Vue SFC source string and returns the top-level content field
+* names that are statically accessed for each plain intlayer variable binding.
+*
+* @param code           - Full `.vue` file source.
+* @param plainVariables - List of plain variable bindings to analyse.
+* @returns Map from dictionary key to the set of accessed top-level field names.
+*          If no fields can be determined for a given key it is omitted from the
+*          map so the caller can fall back to `'all'`.
+*/
+const extractVueIntlayerFieldUsage = (code, plainVariables) => {
+	const result = /* @__PURE__ */ new Map();
+	if (plainVariables.length === 0) return result;
+	const { scriptSource, templateSource } = splitVueSfc(code);
+	for (const { variableName, dictionaryKey } of plainVariables) {
+		const fields = /* @__PURE__ */ new Set();
+		const esc = escapeRegExp(variableName);
+		const scriptRe = new RegExp(`\\b${esc}\\.value\\.(\\w+)`, "g");
+		scriptRe.lastIndex = 0;
+		for (let m = scriptRe.exec(scriptSource); m !== null; m = scriptRe.exec(scriptSource)) {
+			const field = m[1];
+			if (field !== "value") fields.add(field);
+		}
+		if (templateSource) {
+			const templateRe = new RegExp(`\\b${esc}\\.(\\w+)`, "g");
+			templateRe.lastIndex = 0;
+			for (let m = templateRe.exec(templateSource); m !== null; m = templateRe.exec(templateSource)) fields.add(m[1]);
+		}
+		if (fields.size > 0) result.set(dictionaryKey, fields);
+	}
+	return result;
+};
+
+//#endregion
+exports.extractVueIntlayerFieldUsage = extractVueIntlayerFieldUsage;
+//# sourceMappingURL=extractVueFieldUsage.cjs.map

package/dist/cjs/extractVueFieldUsage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractVueFieldUsage.cjs","names":["vueSfc"],"sources":["../../src/extractVueFieldUsage.ts"],"sourcesContent":["/**\n * Extracts intlayer dictionary field usage from a Vue SFC for a set of\n * plain variable bindings (i.e. `const content = useIntlayer('key')`).\n *\n * Two access patterns are recognised:\n *\n *   1. `varName.value.fieldName` in script blocks\n *      Vue's `useIntlayer` returns a reactive `Ref<Content>`, so fields are\n *      accessed one level deeper via `.value`.\n *\n *   2. `varName.fieldName` in the template block\n *      Inside `<template>`, Vue automatically unwraps top-level refs, so\n *      fields are accessed directly without `.value`.\n *\n * The template block is extracted via `@vue/compiler-sfc` so that nested\n * `<template v-for>` / `<template v-if>` tags do not confuse the parser.\n * Falls back to a greedy regex when the package is unavailable.\n */\n\nimport vueSfc from '@vue/compiler-sfc';\n\n/** Escapes special regex characters in a string used as a regex literal. */\nconst escapeRegExp = (str: string): string =>\n  str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n/** Input descriptor for a single plain variable binding. */\nexport type PlainVariableInfo = {\n  /** The local variable name in the script (`content` in `const content = useIntlayer(…)`). */\n  variableName: string;\n  /** The intlayer dictionary key passed to `useIntlayer`. */\n  dictionaryKey: string;\n};\n\n/**\n * Splits a Vue SFC source string into its script and template regions.\n *\n * Uses `@vue/compiler-sfc` to get exact character offsets so that nested\n * `<template>` tags (used by Vue directives like `v-for` / `v-if`) never\n * cause the template region to be mis-identified.\n */\nconst splitVueSfc = (\n  code: string\n): { scriptSource: string; templateSource: string } => {\n  try {\n    const { descriptor } = (\n      vueSfc.parse as (src: string) => { descriptor: any }\n    )(code);\n\n    const templateSource: string = descriptor.template?.content ?? '';\n\n    const scriptParts: string[] = [];\n    if (descriptor.script?.content) scriptParts.push(descriptor.script.content);\n    if (descriptor.scriptSetup?.content)\n      scriptParts.push(descriptor.scriptSetup.content);\n    const scriptSource = scriptParts.join('\\n');\n\n    return { scriptSource, templateSource };\n  } catch {\n    // @vue/compiler-sfc not available or parse failed.\n    // Fall back: use a greedy regex to capture everything between the\n    // outermost <template> tags (robust against nested tags unlike the\n    // non-greedy variant).\n    const templateMatch = /<template(?:[^>]*)>([\\s\\S]*)<\\/template>/i.exec(\n      code\n    );\n    const templateSource = templateMatch ? templateMatch[1] : '';\n    const scriptSource = code.replace(/<template[\\s\\S]*<\\/template>/gi, '');\n    return { scriptSource, templateSource };\n  }\n};\n\n/**\n * Analyzes a Vue SFC source string and returns the top-level content field\n * names that are statically accessed for each plain intlayer variable binding.\n *\n * @param code           - Full `.vue` file source.\n * @param plainVariables - List of plain variable bindings to analyse.\n * @returns Map from dictionary key to the set of accessed top-level field names.\n *          If no fields can be determined for a given key it is omitted from the\n *          map so the caller can fall back to `'all'`.\n */\nexport const extractVueIntlayerFieldUsage = (\n  code: string,\n  plainVariables: PlainVariableInfo[]\n): Map<string, Set<string>> => {\n  const result = new Map<string, Set<string>>();\n\n  if (plainVariables.length === 0) return result;\n\n  const { scriptSource, templateSource } = splitVueSfc(code);\n\n  for (const { variableName, dictionaryKey } of plainVariables) {\n    const fields = new Set<string>();\n    const esc = escapeRegExp(variableName);\n\n    // ── 1. Script pattern: varName.value.fieldName ─────────────────────────\n    // Vue's reactive ref accessor; the actual content fields live one level\n    // deeper than the variable itself.\n    const scriptRe = new RegExp(`\\\\b${esc}\\\\.value\\\\.(\\\\w+)`, 'g');\n    scriptRe.lastIndex = 0;\n    for (\n      let m = scriptRe.exec(scriptSource);\n      m !== null;\n      m = scriptRe.exec(scriptSource)\n    ) {\n      const field = m[1];\n      // Skip chained `.value.value` artefacts\n      if (field !== 'value') fields.add(field);\n    }\n\n    // ── 2. Template pattern: varName.fieldName ─────────────────────────────\n    // Inside `<template>` Vue auto-unwraps refs, so content is accessed\n    // directly without `.value`.\n    if (templateSource) {\n      const templateRe = new RegExp(`\\\\b${esc}\\\\.(\\\\w+)`, 'g');\n\n      templateRe.lastIndex = 0;\n      for (\n        let m = templateRe.exec(templateSource);\n        m !== null;\n        m = templateRe.exec(templateSource)\n      ) {\n        fields.add(m[1]);\n      }\n    }\n\n    if (fields.size > 0) {\n      result.set(dictionaryKey, fields);\n    }\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAM,gBAAgB,QACpB,IAAI,QAAQ,uBAAuB,OAAO;;;;;;;;AAiB5C,MAAM,eACJ,SACqD;AACrD,KAAI;EACF,MAAM,EAAE,eACNA,0BAAO,MACP,KAAK;EAEP,MAAM,iBAAyB,WAAW,UAAU,WAAW;EAE/D,MAAM,cAAwB,EAAE;AAChC,MAAI,WAAW,QAAQ,QAAS,aAAY,KAAK,WAAW,OAAO,QAAQ;AAC3E,MAAI,WAAW,aAAa,QAC1B,aAAY,KAAK,WAAW,YAAY,QAAQ;AAGlD,SAAO;GAAE,cAFY,YAAY,KAAK,KAAK;GAEpB;GAAgB;SACjC;EAKN,MAAM,gBAAgB,4CAA4C,KAChE,KACD;EACD,MAAM,iBAAiB,gBAAgB,cAAc,KAAK;AAE1D,SAAO;GAAE,cADY,KAAK,QAAQ,kCAAkC,GAAG;GAChD;GAAgB;;;;;;;;;;;;;AAc3C,MAAa,gCACX,MACA,mBAC6B;CAC7B,MAAM,yBAAS,IAAI,KAA0B;AAE7C,KAAI,eAAe,WAAW,EAAG,QAAO;CAExC,MAAM,EAAE,cAAc,mBAAmB,YAAY,KAAK;AAE1D,MAAK,MAAM,EAAE,cAAc,mBAAmB,gBAAgB;EAC5D,MAAM,yBAAS,IAAI,KAAa;EAChC,MAAM,MAAM,aAAa,aAAa;EAKtC,MAAM,WAAW,IAAI,OAAO,MAAM,IAAI,oBAAoB,IAAI;AAC9D,WAAS,YAAY;AACrB,OACE,IAAI,IAAI,SAAS,KAAK,aAAa,EACnC,MAAM,MACN,IAAI,SAAS,KAAK,aAAa,EAC/B;GACA,MAAM,QAAQ,EAAE;AAEhB,OAAI,UAAU,QAAS,QAAO,IAAI,MAAM;;AAM1C,MAAI,gBAAgB;GAClB,MAAM,aAAa,IAAI,OAAO,MAAM,IAAI,YAAY,IAAI;AAExD,cAAW,YAAY;AACvB,QACE,IAAI,IAAI,WAAW,KAAK,eAAe,EACvC,MAAM,MACN,IAAI,WAAW,KAAK,eAAe,CAEnC,QAAO,IAAI,EAAE,GAAG;;AAIpB,MAAI,OAAO,OAAO,EAChB,QAAO,IAAI,eAAe,OAAO;;AAIrC,QAAO"}

package/dist/cjs/index.cjs

@@ -1,6 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_vue_intlayer_extract = require('./vue-intlayer-extract.cjs');
+const require_extractVueFieldUsage = require('./extractVueFieldUsage.cjs');
 
+exports.extractVueIntlayerFieldUsage = require_extractVueFieldUsage.extractVueIntlayerFieldUsage;
 exports.intlayerVueExtract = require_vue_intlayer_extract.intlayerVueExtract;
 exports.processVueFile = require_vue_intlayer_extract.processVueFile;
 exports.shouldProcessFile = require_vue_intlayer_extract.shouldProcessFile;

package/dist/esm/extractVueFieldUsage.mjs

@@ -0,0 +1,86 @@
+import vueSfc from "@vue/compiler-sfc";
+
+//#region src/extractVueFieldUsage.ts
+/**
+* Extracts intlayer dictionary field usage from a Vue SFC for a set of
+* plain variable bindings (i.e. `const content = useIntlayer('key')`).
+*
+* Two access patterns are recognised:
+*
+*   1. `varName.value.fieldName` in script blocks
+*      Vue's `useIntlayer` returns a reactive `Ref<Content>`, so fields are
+*      accessed one level deeper via `.value`.
+*
+*   2. `varName.fieldName` in the template block
+*      Inside `<template>`, Vue automatically unwraps top-level refs, so
+*      fields are accessed directly without `.value`.
+*
+* The template block is extracted via `@vue/compiler-sfc` so that nested
+* `<template v-for>` / `<template v-if>` tags do not confuse the parser.
+* Falls back to a greedy regex when the package is unavailable.
+*/
+/** Escapes special regex characters in a string used as a regex literal. */
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Splits a Vue SFC source string into its script and template regions.
+*
+* Uses `@vue/compiler-sfc` to get exact character offsets so that nested
+* `<template>` tags (used by Vue directives like `v-for` / `v-if`) never
+* cause the template region to be mis-identified.
+*/
+const splitVueSfc = (code) => {
+	try {
+		const { descriptor } = vueSfc.parse(code);
+		const templateSource = descriptor.template?.content ?? "";
+		const scriptParts = [];
+		if (descriptor.script?.content) scriptParts.push(descriptor.script.content);
+		if (descriptor.scriptSetup?.content) scriptParts.push(descriptor.scriptSetup.content);
+		return {
+			scriptSource: scriptParts.join("\n"),
+			templateSource
+		};
+	} catch {
+		const templateMatch = /<template(?:[^>]*)>([\s\S]*)<\/template>/i.exec(code);
+		const templateSource = templateMatch ? templateMatch[1] : "";
+		return {
+			scriptSource: code.replace(/<template[\s\S]*<\/template>/gi, ""),
+			templateSource
+		};
+	}
+};
+/**
+* Analyzes a Vue SFC source string and returns the top-level content field
+* names that are statically accessed for each plain intlayer variable binding.
+*
+* @param code           - Full `.vue` file source.
+* @param plainVariables - List of plain variable bindings to analyse.
+* @returns Map from dictionary key to the set of accessed top-level field names.
+*          If no fields can be determined for a given key it is omitted from the
+*          map so the caller can fall back to `'all'`.
+*/
+const extractVueIntlayerFieldUsage = (code, plainVariables) => {
+	const result = /* @__PURE__ */ new Map();
+	if (plainVariables.length === 0) return result;
+	const { scriptSource, templateSource } = splitVueSfc(code);
+	for (const { variableName, dictionaryKey } of plainVariables) {
+		const fields = /* @__PURE__ */ new Set();
+		const esc = escapeRegExp(variableName);
+		const scriptRe = new RegExp(`\\b${esc}\\.value\\.(\\w+)`, "g");
+		scriptRe.lastIndex = 0;
+		for (let m = scriptRe.exec(scriptSource); m !== null; m = scriptRe.exec(scriptSource)) {
+			const field = m[1];
+			if (field !== "value") fields.add(field);
+		}
+		if (templateSource) {
+			const templateRe = new RegExp(`\\b${esc}\\.(\\w+)`, "g");
+			templateRe.lastIndex = 0;
+			for (let m = templateRe.exec(templateSource); m !== null; m = templateRe.exec(templateSource)) fields.add(m[1]);
+		}
+		if (fields.size > 0) result.set(dictionaryKey, fields);
+	}
+	return result;
+};
+
+//#endregion
+export { extractVueIntlayerFieldUsage };
+//# sourceMappingURL=extractVueFieldUsage.mjs.map

package/dist/esm/extractVueFieldUsage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractVueFieldUsage.mjs","names":[],"sources":["../../src/extractVueFieldUsage.ts"],"sourcesContent":["/**\n * Extracts intlayer dictionary field usage from a Vue SFC for a set of\n * plain variable bindings (i.e. `const content = useIntlayer('key')`).\n *\n * Two access patterns are recognised:\n *\n *   1. `varName.value.fieldName` in script blocks\n *      Vue's `useIntlayer` returns a reactive `Ref<Content>`, so fields are\n *      accessed one level deeper via `.value`.\n *\n *   2. `varName.fieldName` in the template block\n *      Inside `<template>`, Vue automatically unwraps top-level refs, so\n *      fields are accessed directly without `.value`.\n *\n * The template block is extracted via `@vue/compiler-sfc` so that nested\n * `<template v-for>` / `<template v-if>` tags do not confuse the parser.\n * Falls back to a greedy regex when the package is unavailable.\n */\n\nimport vueSfc from '@vue/compiler-sfc';\n\n/** Escapes special regex characters in a string used as a regex literal. */\nconst escapeRegExp = (str: string): string =>\n  str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n/** Input descriptor for a single plain variable binding. */\nexport type PlainVariableInfo = {\n  /** The local variable name in the script (`content` in `const content = useIntlayer(…)`). */\n  variableName: string;\n  /** The intlayer dictionary key passed to `useIntlayer`. */\n  dictionaryKey: string;\n};\n\n/**\n * Splits a Vue SFC source string into its script and template regions.\n *\n * Uses `@vue/compiler-sfc` to get exact character offsets so that nested\n * `<template>` tags (used by Vue directives like `v-for` / `v-if`) never\n * cause the template region to be mis-identified.\n */\nconst splitVueSfc = (\n  code: string\n): { scriptSource: string; templateSource: string } => {\n  try {\n    const { descriptor } = (\n      vueSfc.parse as (src: string) => { descriptor: any }\n    )(code);\n\n    const templateSource: string = descriptor.template?.content ?? '';\n\n    const scriptParts: string[] = [];\n    if (descriptor.script?.content) scriptParts.push(descriptor.script.content);\n    if (descriptor.scriptSetup?.content)\n      scriptParts.push(descriptor.scriptSetup.content);\n    const scriptSource = scriptParts.join('\\n');\n\n    return { scriptSource, templateSource };\n  } catch {\n    // @vue/compiler-sfc not available or parse failed.\n    // Fall back: use a greedy regex to capture everything between the\n    // outermost <template> tags (robust against nested tags unlike the\n    // non-greedy variant).\n    const templateMatch = /<template(?:[^>]*)>([\\s\\S]*)<\\/template>/i.exec(\n      code\n    );\n    const templateSource = templateMatch ? templateMatch[1] : '';\n    const scriptSource = code.replace(/<template[\\s\\S]*<\\/template>/gi, '');\n    return { scriptSource, templateSource };\n  }\n};\n\n/**\n * Analyzes a Vue SFC source string and returns the top-level content field\n * names that are statically accessed for each plain intlayer variable binding.\n *\n * @param code           - Full `.vue` file source.\n * @param plainVariables - List of plain variable bindings to analyse.\n * @returns Map from dictionary key to the set of accessed top-level field names.\n *          If no fields can be determined for a given key it is omitted from the\n *          map so the caller can fall back to `'all'`.\n */\nexport const extractVueIntlayerFieldUsage = (\n  code: string,\n  plainVariables: PlainVariableInfo[]\n): Map<string, Set<string>> => {\n  const result = new Map<string, Set<string>>();\n\n  if (plainVariables.length === 0) return result;\n\n  const { scriptSource, templateSource } = splitVueSfc(code);\n\n  for (const { variableName, dictionaryKey } of plainVariables) {\n    const fields = new Set<string>();\n    const esc = escapeRegExp(variableName);\n\n    // ── 1. Script pattern: varName.value.fieldName ─────────────────────────\n    // Vue's reactive ref accessor; the actual content fields live one level\n    // deeper than the variable itself.\n    const scriptRe = new RegExp(`\\\\b${esc}\\\\.value\\\\.(\\\\w+)`, 'g');\n    scriptRe.lastIndex = 0;\n    for (\n      let m = scriptRe.exec(scriptSource);\n      m !== null;\n      m = scriptRe.exec(scriptSource)\n    ) {\n      const field = m[1];\n      // Skip chained `.value.value` artefacts\n      if (field !== 'value') fields.add(field);\n    }\n\n    // ── 2. Template pattern: varName.fieldName ─────────────────────────────\n    // Inside `<template>` Vue auto-unwraps refs, so content is accessed\n    // directly without `.value`.\n    if (templateSource) {\n      const templateRe = new RegExp(`\\\\b${esc}\\\\.(\\\\w+)`, 'g');\n\n      templateRe.lastIndex = 0;\n      for (\n        let m = templateRe.exec(templateSource);\n        m !== null;\n        m = templateRe.exec(templateSource)\n      ) {\n        fields.add(m[1]);\n      }\n    }\n\n    if (fields.size > 0) {\n      result.set(dictionaryKey, fields);\n    }\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAM,gBAAgB,QACpB,IAAI,QAAQ,uBAAuB,OAAO;;;;;;;;AAiB5C,MAAM,eACJ,SACqD;AACrD,KAAI;EACF,MAAM,EAAE,eACN,OAAO,MACP,KAAK;EAEP,MAAM,iBAAyB,WAAW,UAAU,WAAW;EAE/D,MAAM,cAAwB,EAAE;AAChC,MAAI,WAAW,QAAQ,QAAS,aAAY,KAAK,WAAW,OAAO,QAAQ;AAC3E,MAAI,WAAW,aAAa,QAC1B,aAAY,KAAK,WAAW,YAAY,QAAQ;AAGlD,SAAO;GAAE,cAFY,YAAY,KAAK,KAAK;GAEpB;GAAgB;SACjC;EAKN,MAAM,gBAAgB,4CAA4C,KAChE,KACD;EACD,MAAM,iBAAiB,gBAAgB,cAAc,KAAK;AAE1D,SAAO;GAAE,cADY,KAAK,QAAQ,kCAAkC,GAAG;GAChD;GAAgB;;;;;;;;;;;;;AAc3C,MAAa,gCACX,MACA,mBAC6B;CAC7B,MAAM,yBAAS,IAAI,KAA0B;AAE7C,KAAI,eAAe,WAAW,EAAG,QAAO;CAExC,MAAM,EAAE,cAAc,mBAAmB,YAAY,KAAK;AAE1D,MAAK,MAAM,EAAE,cAAc,mBAAmB,gBAAgB;EAC5D,MAAM,yBAAS,IAAI,KAAa;EAChC,MAAM,MAAM,aAAa,aAAa;EAKtC,MAAM,WAAW,IAAI,OAAO,MAAM,IAAI,oBAAoB,IAAI;AAC9D,WAAS,YAAY;AACrB,OACE,IAAI,IAAI,SAAS,KAAK,aAAa,EACnC,MAAM,MACN,IAAI,SAAS,KAAK,aAAa,EAC/B;GACA,MAAM,QAAQ,EAAE;AAEhB,OAAI,UAAU,QAAS,QAAO,IAAI,MAAM;;AAM1C,MAAI,gBAAgB;GAClB,MAAM,aAAa,IAAI,OAAO,MAAM,IAAI,YAAY,IAAI;AAExD,cAAW,YAAY;AACvB,QACE,IAAI,IAAI,WAAW,KAAK,eAAe,EACvC,MAAM,MACN,IAAI,WAAW,KAAK,eAAe,CAEnC,QAAO,IAAI,EAAE,GAAG;;AAIpB,MAAI,OAAO,OAAO,EAChB,QAAO,IAAI,eAAe,OAAO;;AAIrC,QAAO"}

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
 import { intlayerVueExtract, processVueFile, shouldProcessFile } from "./vue-intlayer-extract.mjs";
+import { extractVueIntlayerFieldUsage } from "./extractVueFieldUsage.mjs";
 
-export { intlayerVueExtract, processVueFile, shouldProcessFile };
+export { extractVueIntlayerFieldUsage, intlayerVueExtract, processVueFile, shouldProcessFile };

package/dist/types/extractVueFieldUsage.d.ts

@@ -0,0 +1,38 @@
+//#region src/extractVueFieldUsage.d.ts
+/**
+ * Extracts intlayer dictionary field usage from a Vue SFC for a set of
+ * plain variable bindings (i.e. `const content = useIntlayer('key')`).
+ *
+ * Two access patterns are recognised:
+ *
+ *   1. `varName.value.fieldName` in script blocks
+ *      Vue's `useIntlayer` returns a reactive `Ref<Content>`, so fields are
+ *      accessed one level deeper via `.value`.
+ *
+ *   2. `varName.fieldName` in the template block
+ *      Inside `<template>`, Vue automatically unwraps top-level refs, so
+ *      fields are accessed directly without `.value`.
+ *
+ * The template block is extracted via `@vue/compiler-sfc` so that nested
+ * `<template v-for>` / `<template v-if>` tags do not confuse the parser.
+ * Falls back to a greedy regex when the package is unavailable.
+ */
+/** Input descriptor for a single plain variable binding. */
+type PlainVariableInfo = {
+  /** The local variable name in the script (`content` in `const content = useIntlayer(…)`). */variableName: string; /** The intlayer dictionary key passed to `useIntlayer`. */
+  dictionaryKey: string;
+};
+/**
+ * Analyzes a Vue SFC source string and returns the top-level content field
+ * names that are statically accessed for each plain intlayer variable binding.
+ *
+ * @param code           - Full `.vue` file source.
+ * @param plainVariables - List of plain variable bindings to analyse.
+ * @returns Map from dictionary key to the set of accessed top-level field names.
+ *          If no fields can be determined for a given key it is omitted from the
+ *          map so the caller can fall back to `'all'`.
+ */
+declare const extractVueIntlayerFieldUsage: (code: string, plainVariables: PlainVariableInfo[]) => Map<string, Set<string>>;
+//#endregion
+export { PlainVariableInfo, extractVueIntlayerFieldUsage };
+//# sourceMappingURL=extractVueFieldUsage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractVueFieldUsage.d.ts","names":[],"sources":["../../src/extractVueFieldUsage.ts"],"mappings":";;AA0BA;;;;;AAuDA;;;;;;;;;;;;;KAvDY,iBAAA;EA0DM,6FAxDhB,YAAA;EAEA,aAAA;AAAA;;;;;;;;;;;cAmDW,4BAAA,GACX,IAAA,UACA,cAAA,EAAgB,iBAAA,OACf,GAAA,SAAY,GAAA"}

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
+import { PlainVariableInfo, extractVueIntlayerFieldUsage } from "./extractVueFieldUsage.js";
 import { ExtractPluginOptions, ExtractResult, ExtractedContent, intlayerVueExtract, processVueFile, shouldProcessFile } from "./vue-intlayer-extract.js";
-export { type ExtractPluginOptions, type ExtractResult, type ExtractedContent, intlayerVueExtract, processVueFile, shouldProcessFile };
+export { type ExtractPluginOptions, type ExtractResult, type ExtractedContent, type PlainVariableInfo, extractVueIntlayerFieldUsage, intlayerVueExtract, processVueFile, shouldProcessFile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/vue-compiler",
-  "version": "8.6.10",
+  "version": "8.7.0-canary.0",
   "private": false,
   "description": "Vite-compatible compiler plugin for Vue with Intlayer, providing HMR support, file transformation, and optimized dictionary loading for Vue applications.",
   "keywords": [
@@ -81,8 +81,8 @@
   },
   "dependencies": {
     "@babel/core": "7.29.0",
-    "@intlayer/config": "8.6.10",
-    "@intlayer/types": "8.6.10",
+    "@intlayer/config": "8.7.0-canary.0",
+    "@intlayer/types": "8.7.0-canary.0",
     "@vue/compiler-sfc": ">=3.0.0",
     "fast-glob": "3.3.3",
     "magic-string": "0.30.21"
@@ -98,7 +98,7 @@
     "rimraf": "6.1.3",
     "tsdown": "0.21.7",
     "typescript": "6.0.2",
-    "vitest": "4.1.2"
+    "vitest": "4.1.3"
   },
   "peerDependencies": {
     "@babel/core": ">=6.0.0",