import.meta.location 0.0.0

package/README.md

@@ -0,0 +1,93 @@
+# import.meta.location
+
+`import.meta.location` becomes a plain object with the source file location
+baked in at build time:
+
+```ts
+const here = import.meta.location;
+```
+
+becomes:
+
+```ts
+const here = { line: 1, col: 14, file: "entry.ts" };
+```
+
+Property access works too:
+
+```ts
+console.log(import.meta.location.file);
+```
+
+## Install
+
+```sh
+npm install --save-dev import.meta.location
+```
+
+## Babel
+
+Add the plugin:
+
+```js
+// babel.config.js
+module.exports = {
+  plugins: ["import.meta.location"],
+};
+```
+
+The package also exposes the same plugin at `import.meta.location/plugin`.
+
+### Options
+
+```js
+[
+  "import.meta.location",
+  {
+    // Override the filename in generated objects. By default the plugin
+    // uses the basename of Babel's current filename.
+    filename: "entry.ts",
+  },
+];
+```
+
+## Bun
+
+For code run directly with Bun, use the preload entry:
+
+```toml
+# bunfig.toml
+preload = ["import.meta.location/bun/preload"]
+```
+
+For custom setup:
+
+```ts
+import { importMetaLocationPlugin } from "import.meta.location/bun";
+
+Bun.plugin(importMetaLocationPlugin());
+```
+
+## TypeScript
+
+Ambient typings are available at:
+
+```ts
+/// <reference types="import.meta.location/types" />
+```
+
+They add:
+
+```ts
+interface ImportMeta {
+  readonly location: {
+    readonly line: number;
+    readonly col: number;
+    readonly file: string;
+  };
+}
+```
+
+## License
+
+MIT.

package/dist/bun/index.d.mts

@@ -0,0 +1,8 @@
+//#region src/bun/index.d.ts
+type BunPlugin = Bun.BunPlugin;
+type BunPluginOptions = {
+  /** Glob-ish filter for files to transform. Defaults to JS/TS source outside node_modules. */filter?: RegExp;
+};
+declare const importMetaLocationPlugin: (options?: BunPluginOptions) => BunPlugin;
+//#endregion
+export { BunPluginOptions, importMetaLocationPlugin as default, importMetaLocationPlugin };

package/dist/bun/index.mjs

@@ -0,0 +1,2 @@
+import { t as importMetaLocationPlugin } from "../bun-Bn5rpU4O.mjs";
+export { importMetaLocationPlugin as default, importMetaLocationPlugin };

package/dist/bun/preload.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/bun/preload.mjs

@@ -0,0 +1,5 @@
+import { t as importMetaLocationPlugin } from "../bun-Bn5rpU4O.mjs";
+//#region src/bun/preload.ts
+Bun.plugin(importMetaLocationPlugin());
+//#endregion
+export {};

package/dist/bun-Bn5rpU4O.mjs

@@ -0,0 +1,216 @@
+//#region src/bun/transform.ts
+/**
+* Zero-dependency source transform for Bun's loader path.
+*
+* It rewrites real `import.meta.location` occurrences, skipping strings,
+* comments and regex literals, into object literals containing the original
+* file/line/column.
+*/
+const NEEDLE$1 = "import.meta.location";
+const isWs = (ch) => ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+const isIdentPart = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "$" || ch === "_";
+const regexAllowedBefore = (src, index) => {
+	let i = index - 1;
+	while (i >= 0 && isWs(src[i])) i--;
+	if (i < 0) return true;
+	const ch = src[i];
+	if (isIdentPart(ch) || ch === ")" || ch === "]" || ch === "}") {
+		if (isIdentPart(ch)) {
+			let j = i;
+			while (j >= 0 && isIdentPart(src[j])) j--;
+			const word = src.slice(j + 1, i + 1);
+			return new Set([
+				"return",
+				"typeof",
+				"instanceof",
+				"in",
+				"of",
+				"new",
+				"delete",
+				"void",
+				"do",
+				"else",
+				"yield",
+				"await",
+				"case"
+			]).has(word);
+		}
+		return false;
+	}
+	return true;
+};
+const findOccurrences = (src) => {
+	const out = [];
+	let line = 1;
+	let column = 0;
+	const len = src.length;
+	const advance = (from, count) => {
+		for (let k = 0; k < count; k++) if (src[from + k] === "\n") {
+			line++;
+			column = 0;
+		} else column++;
+	};
+	let i = 0;
+	while (i < len) {
+		const ch = src[i];
+		if (ch === "/" && src[i + 1] === "/") {
+			while (i < len && src[i] !== "\n") {
+				advance(i, 1);
+				i++;
+			}
+			continue;
+		}
+		if (ch === "/" && src[i + 1] === "*") {
+			advance(i, 2);
+			i += 2;
+			while (i < len && !(src[i] === "*" && src[i + 1] === "/")) {
+				advance(i, 1);
+				i++;
+			}
+			advance(i, 2);
+			i += 2;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const quote = ch;
+			advance(i, 1);
+			i++;
+			while (i < len && src[i] !== quote) {
+				if (src[i] === "\\") {
+					advance(i, 2);
+					i += 2;
+					continue;
+				}
+				advance(i, 1);
+				i++;
+			}
+			advance(i, 1);
+			i++;
+			continue;
+		}
+		if (ch === "`") {
+			advance(i, 1);
+			i++;
+			while (i < len && src[i] !== "`") {
+				if (src[i] === "\\") {
+					advance(i, 2);
+					i += 2;
+					continue;
+				}
+				if (src[i] === "$" && src[i + 1] === "{") {
+					advance(i, 2);
+					i += 2;
+					let depth = 1;
+					while (i < len && depth > 0) {
+						if (src.startsWith(NEEDLE$1, i) && !isIdentPart(src[i - 1] ?? " ") && !isIdentPart(src[i + 20] ?? " ")) {
+							out.push({
+								index: i,
+								line,
+								column
+							});
+							advance(i, 20);
+							i += 20;
+							continue;
+						}
+						if (src[i] === "{") depth++;
+						else if (src[i] === "}") depth--;
+						advance(i, 1);
+						i++;
+					}
+					continue;
+				}
+				advance(i, 1);
+				i++;
+			}
+			advance(i, 1);
+			i++;
+			continue;
+		}
+		if (ch === "/" && regexAllowedBefore(src, i)) {
+			advance(i, 1);
+			i++;
+			let inClass = false;
+			while (i < len) {
+				const c = src[i];
+				if (c === "\\") {
+					advance(i, 2);
+					i += 2;
+					continue;
+				}
+				if (c === "[") inClass = true;
+				else if (c === "]") inClass = false;
+				else if (c === "/" && !inClass) break;
+				else if (c === "\n") break;
+				advance(i, 1);
+				i++;
+			}
+			advance(i, 1);
+			i++;
+			continue;
+		}
+		if (src.startsWith(NEEDLE$1, i) && !isIdentPart(src[i - 1] ?? " ") && !isIdentPart(src[i + 20] ?? " ")) {
+			out.push({
+				index: i,
+				line,
+				column
+			});
+			advance(i, 20);
+			i += 20;
+			continue;
+		}
+		advance(i, 1);
+		i++;
+	}
+	return out;
+};
+const locationObject = (filename, line, column) => `({ line: ${line}, col: ${column}, file: ${JSON.stringify(filename)} })`;
+const transform = (source, options) => {
+	if (!source.includes(NEEDLE$1)) return;
+	const occurrences = findOccurrences(source);
+	if (occurrences.length === 0) return;
+	const edits = occurrences.map((occ) => ({
+		start: occ.index,
+		end: occ.index + 20,
+		text: locationObject(options.filename, occ.line, occ.column + 1)
+	}));
+	edits.sort((a, b) => b.start - a.start);
+	let out = source;
+	for (const edit of edits) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+	return out;
+};
+//#endregion
+//#region src/bun/index.ts
+const DEFAULT_FILTER = /^(?:(?!node_modules).)*\.(?:mjs|mts|jsx?|tsx?)$/;
+const NEEDLE = "import.meta.location";
+const loaderFor = (path) => {
+	if (path.endsWith(".tsx")) return "tsx";
+	if (path.endsWith(".ts") || path.endsWith(".mts")) return "ts";
+	if (path.endsWith(".jsx")) return "jsx";
+	return "js";
+};
+const importMetaLocationPlugin = (options = {}) => {
+	const filter = options.filter ?? DEFAULT_FILTER;
+	return {
+		name: "import.meta.location",
+		setup(build) {
+			build.onLoad({ filter }, async ({ path }) => {
+				const source = await Bun.file(path).text();
+				const loader = loaderFor(path);
+				if (!source.includes(NEEDLE)) return {
+					contents: source,
+					loader
+				};
+				return {
+					contents: transform(source, { filename: basename(path) }) ?? source,
+					loader
+				};
+			});
+		}
+	};
+};
+const basename = (path) => {
+	const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	return slash === -1 ? path : path.slice(slash + 1);
+};
+//#endregion
+export { importMetaLocationPlugin as t };

package/dist/plugin/index.cjs

@@ -0,0 +1,54 @@
+let node_path = require("node:path");
+//#region src/plugin/index.ts
+/**
+* Babel plugin: rewrites `import.meta.location` into an object literal with
+* the source location baked in at build time.
+*
+*   import.meta.location
+*
+* becomes:
+*
+*   ({ line: 12, col: 3, file: "entry.ts" })
+*/
+const NEEDLE = "import.meta.location";
+const resolveFilename = (state, override) => {
+	if (override !== void 0 && override !== "") return override;
+	const { filename } = state;
+	if (filename === void 0 || filename === "") return;
+	return (0, node_path.basename)(filename);
+};
+const isImportMetaLocation = (node) => {
+	if (node.type !== "MemberExpression" && node.type !== "OptionalMemberExpression") return false;
+	if (node.computed || node.property.type !== "Identifier" || node.property.name !== "location") return false;
+	const obj = node.object;
+	return obj.type === "MetaProperty" && obj.meta.name === "import" && obj.property.name === "meta";
+};
+const createLocationObject = (t, filename, line, column) => t.objectExpression([
+	t.objectProperty(t.identifier("line"), t.numericLiteral(line)),
+	t.objectProperty(t.identifier("col"), t.numericLiteral(column)),
+	t.objectProperty(t.identifier("file"), t.stringLiteral(filename))
+]);
+const plugin = ({ types: t }) => ({
+	name: "transform-import-meta-location",
+	visitor: { Program(programPath, state) {
+		const source = state.file.code;
+		if (typeof source !== "string" || !source.includes(NEEDLE)) return;
+		const filename = resolveFilename(state, (state.opts ?? {}).filename);
+		if (filename === void 0) return;
+		const rewrite = (locationPath) => {
+			const { node } = locationPath;
+			if (!isImportMetaLocation(node) || !node.loc) return;
+			locationPath.replaceWith(createLocationObject(t, filename, node.loc.start.line, node.loc.start.column + 1));
+		};
+		programPath.traverse({
+			MemberExpression(path) {
+				rewrite(path);
+			},
+			OptionalMemberExpression(path) {
+				rewrite(path);
+			}
+		});
+	} }
+});
+//#endregion
+module.exports = plugin;