@astrojs/ts-plugin 0.2.1 → 0.3.0

package/src/source-mapper.ts

@@ -8,116 +8,100 @@ export type FileMapping = LineMapping[];
 type LineMapping = CharacterMapping[]; // FileMapping[generated_line_index] = LineMapping
 
 type CharacterMapping = [
-    number, // generated character
-    number, // original file
-    number, // original line
-    number //  original index
+	number, // generated character
+	number, // original file
+	number, // original line
+	number //  original index
 ];
 
-type ReorderedChar = [
-    original_character: number,
-    generated_line: number,
-    generated_character: number
-];
+type ReorderedChar = [original_character: number, generated_line: number, generated_character: number];
 
 interface ReorderedMap {
-    [original_line: number]: ReorderedChar[];
+	[original_line: number]: ReorderedChar[];
 }
 
 function binaryInsert(array: number[], value: number): void;
-function binaryInsert<T extends Record<any, number> | number[]>(
-    array: T[],
-    value: T,
-    key: keyof T
-): void;
+function binaryInsert<T extends Record<any, number> | number[]>(array: T[], value: T, key: keyof T): void;
 function binaryInsert<A extends Array<Record<any, number>> | number[]>(
-    array: A,
-    value: A[any],
-    key?: keyof (A[any] & object)
+	array: A,
+	value: A[any],
+	key?: keyof (A[any] & object)
 ) {
-    if (0 === key) key = '0' as keyof A[any];
-    const index = 1 + binarySearch(array, (key ? value[key] : value) as number, key);
-    let i = array.length;
-    while (index !== i--) array[1 + i] = array[i];
-    array[index] = value;
+	if (0 === key) key = '0' as keyof A[any];
+	const index = 1 + binarySearch(array, (key ? value[key] : value) as number, key);
+	let i = array.length;
+	while (index !== i--) array[1 + i] = array[i];
+	array[index] = value;
 }
 
-function binarySearch<T extends object | number>(
-    array: T[],
-    target: number,
-    key?: keyof (T & object)
-) {
-    if (!array || 0 === array.length) return -1;
-    if (0 === key) key = '0' as keyof T;
-    let low = 0;
-    let high = array.length - 1;
-    while (low <= high) {
-        const i = low + ((high - low) >> 1);
-        const item = undefined === key ? array[i] : array[i][key];
-        if (item === target) return i;
-        if (item < target) low = i + 1;
-        else high = i - 1;
-    }
-    if ((low = ~low) < 0) low = ~low - 1;
-    return low;
+function binarySearch<T extends object | number>(array: T[], target: number, key?: keyof (T & object)) {
+	if (!array || 0 === array.length) return -1;
+	if (0 === key) key = '0' as keyof T;
+	let low = 0;
+	let high = array.length - 1;
+	while (low <= high) {
+		const i = low + ((high - low) >> 1);
+		const item = undefined === key ? array[i] : array[i][key];
+		if (item === target) return i;
+		if (item < target) low = i + 1;
+		else high = i - 1;
+	}
+	if ((low = ~low) < 0) low = ~low - 1;
+	return low;
 }
 
 export class SourceMapper {
-    private mappings: FileMapping;
-    private reverseMappings?: ReorderedMap;
-
-    constructor(mappings: FileMapping | string) {
-        if (typeof mappings === 'string') this.mappings = decode(mappings) as FileMapping;
-        else this.mappings = mappings;
-    }
-
-    getOriginalPosition(position: LineChar): LineChar {
-        const lineMap = this.mappings[position.line];
-        if (!lineMap) {
-            return { line: -1, character: -1 };
-        }
-
-        const closestMatch = binarySearch(lineMap, position.character, 0);
-        const match = lineMap[closestMatch];
-        if (!match) {
-            return { line: -1, character: -1 };
-        }
-
-        const { 2: line, 3: character } = match;
-        return { line, character };
-    }
-
-    getGeneratedPosition(position: LineChar): LineChar {
-        if (!this.reverseMappings) this.computeReversed();
-        const lineMap = this.reverseMappings![position.line];
-        if (!lineMap) {
-            return { line: -1, character: -1 };
-        }
-
-        const closestMatch = binarySearch(lineMap, position.character, 0);
-        const match = lineMap[closestMatch];
-        if (!match) {
-            return { line: -1, character: -1 };
-        }
-
-        const { 1: line, 2: character } = match;
-        return { line, character };
-    }
-
-    private computeReversed() {
-        this.reverseMappings = {} as ReorderedMap;
-        for (let generated_line = 0; generated_line !== this.mappings.length; generated_line++) {
-            for (const { 0: generated_index, 2: original_line, 3: original_character_index } of this
-                .mappings[generated_line]) {
-                const reordered_char: ReorderedChar = [
-                    original_character_index,
-                    generated_line,
-                    generated_index
-                ];
-                if (original_line in this.reverseMappings)
-                    binaryInsert(this.reverseMappings[original_line], reordered_char, 0);
-                else this.reverseMappings[original_line] = [reordered_char];
-            }
-        }
-    }
-}
+	private mappings: FileMapping;
+	private reverseMappings?: ReorderedMap;
+
+	constructor(mappings: FileMapping | string) {
+		if (typeof mappings === 'string') this.mappings = decode(mappings) as FileMapping;
+		else this.mappings = mappings;
+	}
+
+	getOriginalPosition(position: LineChar): LineChar {
+		const lineMap = this.mappings[position.line];
+		if (!lineMap) {
+			return { line: -1, character: -1 };
+		}
+
+		const closestMatch = binarySearch(lineMap, position.character, 0);
+		const match = lineMap[closestMatch];
+		if (!match) {
+			return { line: -1, character: -1 };
+		}
+
+		const { 2: line, 3: character } = match;
+		return { line, character };
+	}
+
+	getGeneratedPosition(position: LineChar): LineChar {
+		if (!this.reverseMappings) this.computeReversed();
+		const lineMap = this.reverseMappings![position.line];
+		if (!lineMap) {
+			return { line: -1, character: -1 };
+		}
+
+		const closestMatch = binarySearch(lineMap, position.character, 0);
+		const match = lineMap[closestMatch];
+		if (!match) {
+			return { line: -1, character: -1 };
+		}
+
+		const { 1: line, 2: character } = match;
+		return { line, character };
+	}
+
+	private computeReversed() {
+		this.reverseMappings = {} as ReorderedMap;
+		for (let generated_line = 0; generated_line !== this.mappings.length; generated_line++) {
+			for (const { 0: generated_index, 2: original_line, 3: original_character_index } of this.mappings[
+				generated_line
+			]) {
+				const reordered_char: ReorderedChar = [original_character_index, generated_line, generated_index];
+				if (original_line in this.reverseMappings) binaryInsert(this.reverseMappings[original_line], reordered_char, 0);
+				else this.reverseMappings[original_line] = [reordered_char];
+			}
+		}
+	}
+}

package/src/utils.ts

@@ -1,66 +1,66 @@
 export function isAstroFilePath(filePath: string) {
-  return filePath.endsWith('.astro');
+	return filePath.endsWith('.astro');
 }
 
 export function isVirtualAstroFilePath(filePath: string) {
-  return filePath.endsWith('.astro.ts');
+	return filePath.endsWith('.astro.ts');
 }
 
 export function toRealAstroFilePath(filePath: string) {
-  return filePath.slice(0, -'.ts'.length);
+	return filePath.slice(0, -'.ts'.length);
 }
 
 export function ensureRealAstroFilePath(filePath: string) {
-  return isVirtualAstroFilePath(filePath) ? toRealAstroFilePath(filePath) : filePath;
+	return isVirtualAstroFilePath(filePath) ? toRealAstroFilePath(filePath) : filePath;
 }
 
 export function isNotNullOrUndefined<T>(val: T | undefined | null): val is T {
-  return val !== undefined && val !== null;
+	return val !== undefined && val !== null;
 }
 
 /**
-* Checks if this a section that should be completely ignored
-* because it's purely generated.
-*/
+ * Checks if this a section that should be completely ignored
+ * because it's purely generated.
+ */
 export function isInGeneratedCode(text: string, start: number, end: number) {
-  const lineStart = text.lastIndexOf('\n', start);
-  const lineEnd = text.indexOf('\n', end);
-  const lastStart = text.substring(lineStart, start).lastIndexOf('/*Ωignore_startΩ*/');
-  const lastEnd = text.substring(lineStart, start).lastIndexOf('/*Ωignore_endΩ*/');
-  return lastStart > lastEnd && text.substring(end, lineEnd).includes('/*Ωignore_endΩ*/');
+	const lineStart = text.lastIndexOf('\n', start);
+	const lineEnd = text.indexOf('\n', end);
+	const lastStart = text.substring(lineStart, start).lastIndexOf('/*Ωignore_startΩ*/');
+	const lastEnd = text.substring(lineStart, start).lastIndexOf('/*Ωignore_endΩ*/');
+	return lastStart > lastEnd && text.substring(end, lineEnd).includes('/*Ωignore_endΩ*/');
 }
 
 /**
-* Checks that this isn't a text span that should be completely ignored
-* because it's purely generated.
-*/
+ * Checks that this isn't a text span that should be completely ignored
+ * because it's purely generated.
+ */
 export function isNoTextSpanInGeneratedCode(text: string, span: ts.TextSpan) {
-  return !isInGeneratedCode(text, span.start, span.start + span.length);
+	return !isInGeneratedCode(text, span.start, span.start + span.length);
 }
 
 /**
-* Replace all occurrences of a string within an object with another string,
-*/
+ * Replace all occurrences of a string within an object with another string,
+ */
 export function replaceDeep<T extends Record<string, any>>(
-  obj: T,
-  searchStr: string | RegExp,
-  replacementStr: string
+	obj: T,
+	searchStr: string | RegExp,
+	replacementStr: string
 ): T {
-  return _replaceDeep(obj);
+	return _replaceDeep(obj);
 
-  function _replaceDeep(_obj: any): any {
-      if (typeof _obj === 'string') {
-          return _obj.replace(searchStr, replacementStr);
-      }
-      if (Array.isArray(_obj)) {
-          return _obj.map((entry) => _replaceDeep(entry));
-      }
-      if (typeof _obj === 'object') {
-          return Object.keys(_obj).reduce((_o, key) => {
-              _o[key] = _replaceDeep(_obj[key]);
-              return _o;
-          }, {} as any);
-      }
-      return _obj;
-  }
-}
+	function _replaceDeep(_obj: any): any {
+		if (typeof _obj === 'string') {
+			return _obj.replace(searchStr, replacementStr);
+		}
+		if (Array.isArray(_obj)) {
+			return _obj.map((entry) => _replaceDeep(entry));
+		}
+		if (typeof _obj === 'object') {
+			return Object.keys(_obj).reduce((_o, key) => {
+				_o[key] = _replaceDeep(_obj[key]);
+				return _o;
+			}, {} as any);
+		}
+		return _obj;
+	}
+}