@generaltranslation/vue-extractor 0.0.0

package/LICENSE.md

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 General Translation, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export { resolveVueCompilerOptions } from './internal/config/resolveVueCompilerOptions.js';
+export type { VueCompilerOptionsResolution, VueCompilerOptionsResolverOptions, } from './internal/config/resolveVueCompilerOptions.js';

package/dist/config.js

@@ -0,0 +1,2 @@
+import { resolveVueCompilerOptions } from "./internal/config/resolveVueCompilerOptions.js";
+export { resolveVueCompilerOptions };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { extractFromVueSource } from './internal/extractFromVueSource.js';
+export type { VueCompilerOptions, VueCompiler, VueExtractionMetadata, VueExtractionOptions, VueExtractionOutput, VueExtractionResult, VueSourceCode, } from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+import { extractFromVueSource } from "./internal/extractFromVueSource.js";
+export { extractFromVueSource };

package/dist/internal/compilerAst.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Vue compiler node discriminants used by the extractor.
+ *
+ * These values are defined locally so the production bundle can inspect the
+ * compiler-sfc AST without importing a second runtime copy of compiler-dom.
+ * The matching test intentionally compares them with the installed compiler.
+ */
+export declare const NodeTypes: {
+    readonly ELEMENT: 1;
+    readonly TEXT: 2;
+    readonly COMMENT: 3;
+    readonly SIMPLE_EXPRESSION: 4;
+    readonly INTERPOLATION: 5;
+    readonly ATTRIBUTE: 6;
+    readonly DIRECTIVE: 7;
+};
+/** Vue element discriminants used by the extractor. */
+export declare const ElementTypes: {
+    readonly COMPONENT: 1;
+    readonly SLOT: 2;
+};
+type CompilerPosition = {
+    column: number;
+    line: number;
+    offset: number;
+};
+type CompilerLocation = {
+    end?: Partial<CompilerPosition>;
+    source?: string;
+    start?: Partial<CompilerPosition>;
+};
+/**
+ * Rebases a compiler AST from template-content coordinates to its full SFC.
+ *
+ * The input is intentionally `unknown`: Vue compiler AST types are not part
+ * of the extractor's public declaration graph and differ across supported
+ * Vue releases. Runtime structural guards preserve safety at this internal
+ * boundary without making consumers install the extractor's test compiler.
+ */
+export declare function shiftCompilerAstLocations(ast: unknown, origin: CompilerPosition): void;
+/** Rebases one structurally validated Vue compiler source range. */
+export declare function shiftCompilerLocation(location: CompilerLocation, origin: CompilerPosition, shiftedPositions?: WeakSet<object>): void;
+export {};

package/dist/internal/compilerAst.js

@@ -0,0 +1,77 @@
+//#region src/internal/compilerAst.ts
+/**
+* Vue compiler node discriminants used by the extractor.
+*
+* These values are defined locally so the production bundle can inspect the
+* compiler-sfc AST without importing a second runtime copy of compiler-dom.
+* The matching test intentionally compares them with the installed compiler.
+*/
+const NodeTypes = {
+	ELEMENT: 1,
+	TEXT: 2,
+	COMMENT: 3,
+	SIMPLE_EXPRESSION: 4,
+	INTERPOLATION: 5,
+	ATTRIBUTE: 6,
+	DIRECTIVE: 7
+};
+/** Vue element discriminants used by the extractor. */
+const ElementTypes = {
+	COMPONENT: 1,
+	SLOT: 2
+};
+/**
+* Rebases a compiler AST from template-content coordinates to its full SFC.
+*
+* The input is intentionally `unknown`: Vue compiler AST types are not part
+* of the extractor's public declaration graph and differ across supported
+* Vue releases. Runtime structural guards preserve safety at this internal
+* boundary without making consumers install the extractor's test compiler.
+*/
+function shiftCompilerAstLocations(ast, origin) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const shiftedPositions = /* @__PURE__ */ new WeakSet();
+	const visit = (value) => {
+		if (!value || typeof value !== "object" || seen.has(value)) return;
+		seen.add(value);
+		if (isCompilerLocation(value)) {
+			shiftCompilerLocation(value, origin, shiftedPositions);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child);
+			return;
+		}
+		for (const child of Object.values(value)) visit(child);
+	};
+	visit(ast);
+}
+/** Rebases one structurally validated Vue compiler source range. */
+function shiftCompilerLocation(location, origin, shiftedPositions = /* @__PURE__ */ new WeakSet()) {
+	if (location.start) shiftCompilerPosition(location.start, origin, shiftedPositions);
+	if (location.end) shiftCompilerPosition(location.end, origin, shiftedPositions);
+}
+/** Rebases a template-relative position to the containing SFC. */
+function shiftCompilerPosition(position, origin, shiftedPositions) {
+	if (shiftedPositions.has(position)) return;
+	shiftedPositions.add(position);
+	const line = position.line ?? 1;
+	const column = position.column ?? 1;
+	const offset = position.offset ?? 0;
+	position.line = origin.line + line - 1;
+	position.column = line === 1 ? origin.column + column - 1 : column;
+	position.offset = origin.offset + offset;
+}
+/** Identifies Vue compiler source locations while skipping Babel AST ranges. */
+function isCompilerLocation(value) {
+	if (!("start" in value) || !("end" in value) || !("source" in value)) return false;
+	return isCompilerPosition(value.start) && isCompilerPosition(value.end);
+}
+/** Returns whether a value has Vue compiler line, column, and offset fields. */
+function isCompilerPosition(value) {
+	return !!value && typeof value === "object" && "line" in value && typeof value.line === "number" && "column" in value && typeof value.column === "number" && "offset" in value && typeof value.offset === "number";
+}
+//#endregion
+export { ElementTypes, NodeTypes, shiftCompilerAstLocations, shiftCompilerLocation };
+
+//# sourceMappingURL=compilerAst.js.map

package/dist/internal/compilerAst.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerAst.js","names":[],"sources":["../../src/internal/compilerAst.ts"],"sourcesContent":["/**\n * Vue compiler node discriminants used by the extractor.\n *\n * These values are defined locally so the production bundle can inspect the\n * compiler-sfc AST without importing a second runtime copy of compiler-dom.\n * The matching test intentionally compares them with the installed compiler.\n */\nexport const NodeTypes = {\n  ELEMENT: 1,\n  TEXT: 2,\n  COMMENT: 3,\n  SIMPLE_EXPRESSION: 4,\n  INTERPOLATION: 5,\n  ATTRIBUTE: 6,\n  DIRECTIVE: 7,\n} as const;\n\n/** Vue element discriminants used by the extractor. */\nexport const ElementTypes = {\n  COMPONENT: 1,\n  SLOT: 2,\n} as const;\n\ntype CompilerPosition = {\n  column: number;\n  line: number;\n  offset: number;\n};\n\ntype CompilerLocation = {\n  end?: Partial<CompilerPosition>;\n  source?: string;\n  start?: Partial<CompilerPosition>;\n};\n\n/**\n * Rebases a compiler AST from template-content coordinates to its full SFC.\n *\n * The input is intentionally `unknown`: Vue compiler AST types are not part\n * of the extractor's public declaration graph and differ across supported\n * Vue releases. Runtime structural guards preserve safety at this internal\n * boundary without making consumers install the extractor's test compiler.\n */\nexport function shiftCompilerAstLocations(\n  ast: unknown,\n  origin: CompilerPosition\n): void {\n  const seen = new WeakSet<object>();\n  const shiftedPositions = new WeakSet<object>();\n\n  const visit = (value: unknown): void => {\n    if (!value || typeof value !== 'object' || seen.has(value)) return;\n    seen.add(value);\n\n    if (isCompilerLocation(value)) {\n      shiftCompilerLocation(value, origin, shiftedPositions);\n      return;\n    }\n    if (Array.isArray(value)) {\n      for (const child of value) visit(child);\n      return;\n    }\n    for (const child of Object.values(value)) visit(child);\n  };\n\n  visit(ast);\n}\n\n/** Rebases one structurally validated Vue compiler source range. */\nexport function shiftCompilerLocation(\n  location: CompilerLocation,\n  origin: CompilerPosition,\n  shiftedPositions = new WeakSet<object>()\n): void {\n  if (location.start) {\n    shiftCompilerPosition(location.start, origin, shiftedPositions);\n  }\n  if (location.end) {\n    shiftCompilerPosition(location.end, origin, shiftedPositions);\n  }\n}\n\n/** Rebases a template-relative position to the containing SFC. */\nfunction shiftCompilerPosition(\n  position: Partial<CompilerPosition>,\n  origin: CompilerPosition,\n  shiftedPositions: WeakSet<object>\n): void {\n  if (shiftedPositions.has(position)) return;\n  shiftedPositions.add(position);\n  const line = position.line ?? 1;\n  const column = position.column ?? 1;\n  const offset = position.offset ?? 0;\n  position.line = origin.line + line - 1;\n  position.column = line === 1 ? origin.column + column - 1 : column;\n  position.offset = origin.offset + offset;\n}\n\n/** Identifies Vue compiler source locations while skipping Babel AST ranges. */\nfunction isCompilerLocation(value: object): value is CompilerLocation {\n  if (!('start' in value) || !('end' in value) || !('source' in value)) {\n    return false;\n  }\n  return isCompilerPosition(value.start) && isCompilerPosition(value.end);\n}\n\n/** Returns whether a value has Vue compiler line, column, and offset fields. */\nfunction isCompilerPosition(value: unknown): value is CompilerPosition {\n  return (\n    !!value &&\n    typeof value === 'object' &&\n    'line' in value &&\n    typeof value.line === 'number' &&\n    'column' in value &&\n    typeof value.column === 'number' &&\n    'offset' in value &&\n    typeof value.offset === 'number'\n  );\n}\n"],"mappings":";;;;;;;;AAOA,MAAa,YAAY;CACvB,SAAS;CACT,MAAM;CACN,SAAS;CACT,mBAAmB;CACnB,eAAe;CACf,WAAW;CACX,WAAW;CACZ;;AAGD,MAAa,eAAe;CAC1B,WAAW;CACX,MAAM;CACP;;;;;;;;;AAsBD,SAAgB,0BACd,KACA,QACM;CACN,MAAM,uBAAO,IAAI,SAAiB;CAClC,MAAM,mCAAmB,IAAI,SAAiB;CAE9C,MAAM,SAAS,UAAyB;AACtC,MAAI,CAAC,SAAS,OAAO,UAAU,YAAY,KAAK,IAAI,MAAM,CAAE;AAC5D,OAAK,IAAI,MAAM;AAEf,MAAI,mBAAmB,MAAM,EAAE;AAC7B,yBAAsB,OAAO,QAAQ,iBAAiB;AACtD;;AAEF,MAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,QAAK,MAAM,SAAS,MAAO,OAAM,MAAM;AACvC;;AAEF,OAAK,MAAM,SAAS,OAAO,OAAO,MAAM,CAAE,OAAM,MAAM;;AAGxD,OAAM,IAAI;;;AAIZ,SAAgB,sBACd,UACA,QACA,mCAAmB,IAAI,SAAiB,EAClC;AACN,KAAI,SAAS,MACX,uBAAsB,SAAS,OAAO,QAAQ,iBAAiB;AAEjE,KAAI,SAAS,IACX,uBAAsB,SAAS,KAAK,QAAQ,iBAAiB;;;AAKjE,SAAS,sBACP,UACA,QACA,kBACM;AACN,KAAI,iBAAiB,IAAI,SAAS,CAAE;AACpC,kBAAiB,IAAI,SAAS;CAC9B,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,SAAS,SAAS,UAAU;CAClC,MAAM,SAAS,SAAS,UAAU;AAClC,UAAS,OAAO,OAAO,OAAO,OAAO;AACrC,UAAS,SAAS,SAAS,IAAI,OAAO,SAAS,SAAS,IAAI;AAC5D,UAAS,SAAS,OAAO,SAAS;;;AAIpC,SAAS,mBAAmB,OAA0C;AACpE,KAAI,EAAE,WAAW,UAAU,EAAE,SAAS,UAAU,EAAE,YAAY,OAC5D,QAAO;AAET,QAAO,mBAAmB,MAAM,MAAM,IAAI,mBAAmB,MAAM,IAAI;;;AAIzE,SAAS,mBAAmB,OAA2C;AACrE,QACE,CAAC,CAAC,SACF,OAAO,UAAU,YACjB,UAAU,SACV,OAAO,MAAM,SAAS,YACtB,YAAY,SACZ,OAAO,MAAM,WAAW,YACxB,YAAY,SACZ,OAAO,MAAM,WAAW"}

package/dist/internal/config/resolveVueCompilerOptions.d.ts

@@ -0,0 +1,23 @@
+import type { VueCompilerOptions } from '../../types.js';
+/** Result of resolving hash-affecting options from project configuration. */
+export type VueCompilerOptionsResolution = {
+    /** Static compiler options that must be passed to Vue source extraction. */
+    compilerOptions: VueCompilerOptions;
+    /** Diagnostics that make extraction unsafe until the configuration is fixed. */
+    errors: string[];
+};
+/** Controls project configuration discovery for compiler-option resolution. */
+export type VueCompilerOptionsResolverOptions = {
+    /** A single explicit Vite config path, resolved relative to the project root. */
+    viteConfigPath?: string;
+};
+/**
+ * Resolves hash-affecting Vue template compiler options without executing
+ * project configuration files.
+ *
+ * Explicit `gt.config.json` values are combined with statically analyzable
+ * Vite and Nuxt configuration. Conflicting, dynamic, or unsupported relevant
+ * options produce errors so extraction never publishes hashes calculated with
+ * compiler behavior that the runtime does not share.
+ */
+export declare function resolveVueCompilerOptions(cwd: string, explicitOptions: VueCompilerOptions | undefined, resolverOptions?: VueCompilerOptionsResolverOptions): VueCompilerOptionsResolution;