@tsrx/typescript-plugin 0.3.32 → 0.3.34

package/src/utils.js

@@ -1,57 +0,0 @@
-export const DEBUG = process.env.RIPPLE_DEBUG === 'true';
-// Matches valid JS/CSS identifier characters: word chars, dashes (CSS), $, and # (Ripple shorthands)
-export const charAllowedWordRegex = /[\w\-$#]/;
-
-/**
- * Create a logging utility with a specific label
- * @param {string} label
- * @returns {{
- * 	log: (...args: unknown[]) => void,
- * 	logError: (...args: unknown[]) => void,
- * 	logWarning: (...args: unknown[]) => void,
- * }}
- */
-export function createLogging(label) {
-	return {
-		log(...args) {
-			if (DEBUG) {
-				console.log(label, ...args);
-			}
-		},
-		logError(...args) {
-			if (DEBUG) {
-				console.error(label, ...args);
-			}
-		},
-		logWarning(...args) {
-			if (DEBUG) {
-				console.warn(label, ...args);
-			}
-		},
-	};
-}
-
-/**
- * Get the word at a specific position in the text
- * @param {string} text
- * @param {number} start
- * @returns {{word: string, start: number, end: number}}
- */
-export function getWordFromPosition(text, start) {
-	let wordStart = start;
-	let wordEnd = start;
-	while (wordStart > 0 && charAllowedWordRegex.test(text[wordStart - 1])) {
-		wordStart--;
-	}
-	while (wordEnd < text.length && charAllowedWordRegex.test(text[wordEnd])) {
-		wordEnd++;
-	}
-
-	const word = text.substring(wordStart, wordEnd);
-
-	return {
-		word,
-		start: wordStart,
-		end: wordEnd,
-	};
-}

package/tests/compiler-resolution.test.js

@@ -1,205 +0,0 @@
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { cleanup_fixture_workspaces, create_fixture_workspace } from './workspace-fixtures.js';
-import fs from 'fs';
-
-/** @import { WORKSPACE_CONFIGS } from './workspace-fixtures.js'; */
-
-const {
-	is_ripple_file,
-	find_workspace_compiler_entry_for_file,
-	COMPILER_CANDIDATES,
-	RIPPLE_EXTENSIONS,
-	_reset_for_test,
-} = require('../src/language.js');
-
-describe('typescript-plugin compiler resolution', () => {
-	beforeEach(() => {
-		_reset_for_test();
-	});
-
-	afterEach(() => {
-		cleanup_fixture_workspaces();
-	});
-
-	describe('extension metadata', () => {
-		it('recognizes .tsrx as the only supported extension', () => {
-			expect(RIPPLE_EXTENSIONS).toEqual(['.tsrx']);
-		});
-
-		it('maps all compiler candidates to .tsrx', () => {
-			const ripple_candidate = COMPILER_CANDIDATES.find(
-				([package_name]) => package_name === '@tsrx/ripple',
-			);
-			const react_candidate = COMPILER_CANDIDATES.find(
-				([package_name]) => package_name === '@tsrx/react',
-			);
-			const solid_candidate = COMPILER_CANDIDATES.find(
-				([package_name]) => package_name === '@tsrx/solid',
-			);
-			const preact_candidate = COMPILER_CANDIDATES.find(
-				([package_name]) => package_name === '@tsrx/preact',
-			);
-
-			if (!ripple_candidate || !react_candidate || !solid_candidate || !preact_candidate) {
-				throw new Error('Missing compiler candidates');
-			}
-
-			expect(ripple_candidate[2]).toEqual(['.tsrx']);
-			expect(react_candidate[2]).toEqual(['.tsrx']);
-			expect(solid_candidate[2]).toEqual(['.tsrx']);
-			expect(preact_candidate[2]).toEqual(['.tsrx']);
-		});
-	});
-
-	describe('is_ripple_file', () => {
-		it.each([
-			['Component.tsrx', true],
-			['/path/to/Component.tsrx', true],
-			['Component.ripple', false],
-			['Component.rsrx', false],
-			['Component.ts', false],
-			['Component.tsx', false],
-			['Component.js', false],
-			['Component.jsx', false],
-			['', false],
-		])('returns %j for %j', (file_name, expected) => {
-			expect(is_ripple_file(file_name)).toBe(expected);
-		});
-	});
-
-	describe('workspace resolution', () => {
-		it('selects the ripple compiler in a ripple-only project', () => {
-			const workspace = create_fixture_workspace('ripple-only');
-			const file_name = path.join(workspace, 'src', 'App.tsrx');
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'ripple', 'src', 'index.js');
-
-			expect(find_workspace_compiler_entry_for_file(file_name, fs.existsSync, new Map())).toBe(
-				expected,
-			);
-		});
-
-		it('selects the react compiler in a react-only project', () => {
-			const workspace = create_fixture_workspace('react-only');
-			const file_name = path.join(workspace, 'src', 'App.tsrx');
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'react', 'src', 'index.js');
-
-			expect(find_workspace_compiler_entry_for_file(file_name, fs.existsSync, new Map())).toBe(
-				expected,
-			);
-		});
-
-		it('selects the preact compiler in a preact-only project', () => {
-			const workspace = create_fixture_workspace('preact-only');
-			const file_name = path.join(workspace, 'src', 'App.tsrx');
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'preact', 'src', 'index.js');
-
-			expect(find_workspace_compiler_entry_for_file(file_name, fs.existsSync, new Map())).toBe(
-				expected,
-			);
-		});
-
-		it('prefers the ripple compiler when both compilers exist in a ripple project', () => {
-			const workspace = create_fixture_workspace('both');
-			const file_name = path.join(workspace, 'src', 'App.tsrx');
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'ripple', 'src', 'index.js');
-
-			expect(find_workspace_compiler_entry_for_file(file_name, fs.existsSync, new Map())).toBe(
-				expected,
-			);
-		});
-
-		it('prefers the react compiler when both compilers exist in a react project', () => {
-			const workspace = create_fixture_workspace('both-react');
-			const file_name = path.join(workspace, 'src', 'App.tsrx');
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'react', 'src', 'index.js');
-
-			expect(find_workspace_compiler_entry_for_file(file_name, fs.existsSync, new Map())).toBe(
-				expected,
-			);
-		});
-
-		it('prefers the preact compiler when multiple compilers exist in a preact project', () => {
-			const workspace = create_fixture_workspace('both-preact');
-			const file_name = path.join(workspace, 'src', 'App.tsrx');
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'preact', 'src', 'index.js');
-
-			expect(find_workspace_compiler_entry_for_file(file_name, fs.existsSync, new Map())).toBe(
-				expected,
-			);
-		});
-
-		it('walks up nested directories to find the nearest compiler', () => {
-			const workspace = create_fixture_workspace('ripple-only');
-			const file_name = path.join(workspace, 'src', 'nested', 'components', 'App.tsrx');
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'ripple', 'src', 'index.js');
-
-			expect(find_workspace_compiler_entry_for_file(file_name, fs.existsSync, new Map())).toBe(
-				expected,
-			);
-		});
-
-		it('returns undefined when no compiler exists', () => {
-			expect(
-				find_workspace_compiler_entry_for_file('/workspace/src/App.tsrx', () => false, new Map()),
-			).toBeUndefined();
-		});
-	});
-
-	describe('cache behavior', () => {
-		it('reuses the cached result for repeated lookups in the same directory', () => {
-			const workspace = create_fixture_workspace('ripple-only');
-			const compiler_path_map = new Map();
-			const expected = path.join(workspace, 'node_modules', '@tsrx', 'ripple', 'src', 'index.js');
-			let exists_sync_calls = 0;
-
-			/** @param {import('fs').PathLike} file_path */
-			const exists_sync = (file_path) => {
-				exists_sync_calls += 1;
-				return fs.existsSync(file_path);
-			};
-
-			expect(
-				find_workspace_compiler_entry_for_file(
-					path.join(workspace, 'src', 'A.tsrx'),
-					exists_sync,
-					compiler_path_map,
-				),
-			).toBe(expected);
-			expect(
-				find_workspace_compiler_entry_for_file(
-					path.join(workspace, 'src', 'B.tsrx'),
-					exists_sync,
-					compiler_path_map,
-				),
-			).toBe(expected);
-			expect(exists_sync_calls).toBeGreaterThan(0);
-		});
-	});
-
-	describe('project permutation matrix', () => {
-		/** @type {{ name: keyof typeof WORKSPACE_CONFIGS, expected: string[] }[]} */
-		const cases = [
-			{ name: 'ripple-only', expected: ['@tsrx', 'ripple'] },
-			{ name: 'react-only', expected: ['@tsrx', 'react'] },
-			{ name: 'solid-only', expected: ['@tsrx', 'solid'] },
-			{ name: 'preact-only', expected: ['@tsrx', 'preact'] },
-			{ name: 'both', expected: ['@tsrx', 'ripple'] },
-			{ name: 'both-react', expected: ['@tsrx', 'react'] },
-			{ name: 'both-preact', expected: ['@tsrx', 'preact'] },
-		];
-
-		for (const test_case of cases) {
-			it(`${test_case.name} resolves App.tsrx to the expected compiler`, () => {
-				const workspace = create_fixture_workspace(test_case.name);
-				const compiler_path = find_workspace_compiler_entry_for_file(
-					path.join(workspace, 'src', 'App.tsrx'),
-					fs.existsSync,
-					new Map(),
-				);
-
-				expect(compiler_path).toContain(path.join(...test_case.expected));
-			});
-		}
-	});
-});

package/tests/fixtures/workspaces/both/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@ripple-ts/fixture-ripple-project",
-  "private": true,
-  "devDependencies": {
-    "@tsrx/ripple": "workspace:*",
-    "@ripple-ts/vite-plugin": "workspace:*",
-    "ripple": "workspace:*"
-  }
-}

package/tests/fixtures/workspaces/both-react/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "@tsrx/fixture-react-project",
-  "private": true,
-  "devDependencies": {
-    "@tsrx/react": "workspace:*",
-    "@tsrx/vite-plugin-react": "workspace:*"
-  }
-}

package/tests/fixtures/workspaces/react-only/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "@tsrx/fixture-react-only-project",
-  "private": true,
-  "devDependencies": {
-    "@tsrx/react": "workspace:*",
-    "@tsrx/vite-plugin-react": "workspace:*"
-  }
-}

package/tests/fixtures/workspaces/ripple-only/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@ripple-ts/fixture-ripple-only-project",
-  "private": true,
-  "devDependencies": {
-    "@tsrx/ripple": "workspace:*",
-    "@ripple-ts/vite-plugin": "workspace:*",
-    "ripple": "workspace:*"
-  }
-}

package/tests/plugin-integration.test.js

@@ -1,120 +0,0 @@
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { cleanup_fixture_workspaces, create_fixture_workspace } from './workspace-fixtures.js';
-import * as ts from 'typescript';
-import { getRippleLanguagePlugin, TSRXVirtualCode, _reset_for_test } from '../src/language.js';
-
-/**
- * @param {string} source
- * @returns {import('typescript').IScriptSnapshot}
- */
-function create_snapshot(source) {
-	return ts.ScriptSnapshot.fromString(source);
-}
-
-/**
- * @returns {ReturnType<typeof getRippleLanguagePlugin>}
- */
-function create_plugin() {
-	return getRippleLanguagePlugin();
-}
-
-/**
- * @param {ReturnType<typeof getRippleLanguagePlugin>} plugin
- * @param {string} file_name
- * @param {string} source
- * @returns {TSRXVirtualCode}
- */
-function create_virtual_code(plugin, file_name, source) {
-	const create_virtual_code_fn = plugin.createVirtualCode;
-	if (typeof create_virtual_code_fn !== 'function') {
-		throw new Error('Language plugin does not expose createVirtualCode');
-	}
-
-	/** @type {import('@volar/language-core').CodegenContext<string>} */
-	const ctx = { getAssociatedScript: () => undefined };
-
-	return /** @type {TSRXVirtualCode} */ (
-		create_virtual_code_fn(file_name, 'ripple', create_snapshot(source), ctx)
-	);
-}
-
-describe('typescript-plugin language plugin integration', () => {
-	beforeEach(() => {
-		_reset_for_test();
-	});
-
-	afterEach(() => {
-		cleanup_fixture_workspaces();
-	});
-
-	it('recognizes only .tsrx through the language plugin', () => {
-		const plugin = create_plugin();
-
-		expect(plugin.getLanguageId('/tmp/App.tsrx')).toBe('ripple');
-		expect(plugin.getLanguageId('/tmp/App.ripple')).toBeUndefined();
-		expect(plugin.getLanguageId('/tmp/App.rsrx')).toBeUndefined();
-		expect(plugin.getLanguageId('/tmp/App.ts')).toBeUndefined();
-	});
-
-	it('creates virtual code with the ripple compiler in a ripple project', () => {
-		const plugin = create_plugin();
-		const workspace = create_fixture_workspace('both');
-		const file_name = path.join(workspace, 'src', 'App.tsrx');
-		const virtual_code = create_virtual_code(plugin, file_name, '<div>Hello Ripple</div>');
-
-		expect(virtual_code).toBeInstanceOf(TSRXVirtualCode);
-		expect(virtual_code.generatedCode).toContain('compiler:ripple');
-		expect(virtual_code.generatedCode).toContain(file_name);
-	});
-
-	it('creates virtual code with the react compiler in a react project when both compilers exist', () => {
-		const plugin = create_plugin();
-		const workspace = create_fixture_workspace('both-react');
-		const file_name = path.join(workspace, 'src', 'App.tsrx');
-		const virtual_code = create_virtual_code(
-			plugin,
-			file_name,
-			'export default function App() { return <div>Hello TSRX</div>; }',
-		);
-
-		expect(virtual_code).toBeInstanceOf(TSRXVirtualCode);
-		expect(virtual_code.generatedCode).toContain('compiler:react');
-	});
-
-	it('creates virtual code with the react compiler in a react-only project', () => {
-		const plugin = create_plugin();
-		const workspace = create_fixture_workspace('react-only');
-		const file_name = path.join(workspace, 'src', 'App.tsrx');
-		const virtual_code = create_virtual_code(plugin, file_name, 'export default <div>Hello</div>;');
-
-		expect(virtual_code).toBeInstanceOf(TSRXVirtualCode);
-		expect(virtual_code.generatedCode).toContain('compiler:react');
-	});
-
-	it('creates virtual code with the ripple compiler in a ripple-only project', () => {
-		const plugin = create_plugin();
-		const workspace = create_fixture_workspace('ripple-only');
-		const file_name = path.join(workspace, 'src', 'App.tsrx');
-		const virtual_code = create_virtual_code(plugin, file_name, '<div>Hello</div>');
-
-		expect(virtual_code).toBeInstanceOf(TSRXVirtualCode);
-		expect(virtual_code.generatedCode).toContain('compiler:ripple');
-	});
-
-	it('returns undefined for non-tsrx files before compiler resolution', () => {
-		const plugin = create_plugin();
-		const create_virtual_code_fn = /** @type {any} */ (plugin.createVirtualCode);
-		if (typeof create_virtual_code_fn !== 'function') {
-			throw new Error('Language plugin does not expose createVirtualCode');
-		}
-
-		expect(
-			create_virtual_code_fn(
-				path.join(create_fixture_workspace('both'), 'src', 'App.ripple'),
-				'ripple',
-				create_snapshot('<div>Hello</div>'),
-			),
-		).toBeUndefined();
-	});
-});

package/tests/workspace-fixtures.js

@@ -1,244 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-const COMPILER_STUBS = {
-	ripple: `module.exports = {
-	compile_to_volar_mappings(source, filename) {
-		const code = \`/* compiler:ripple */\\nexport const filename = \${JSON.stringify(filename)};\\nexport default \${JSON.stringify(source)};\`;
-		return {
-			code,
-			mappings: [
-				{
-					sourceOffsets: [0],
-					generatedOffsets: [0],
-					lengths: [source.length],
-					generatedLengths: [source.length],
-					data: {
-						verification: false,
-						completion: true,
-						semantic: true,
-						navigation: true,
-						structure: true,
-						format: true,
-						customData: {},
-					},
-				},
-			],
-			cssMappings: [],
-			errors: [],
-		};
-	},
-};
-`,
-	react: `module.exports = {
-	compile_to_volar_mappings(source, filename) {
-		const code = \`/* compiler:react */\\nexport const filename = \${JSON.stringify(filename)};\\nexport default \${JSON.stringify(source)};\`;
-		return {
-			code,
-			mappings: [
-				{
-					sourceOffsets: [0],
-					generatedOffsets: [0],
-					lengths: [source.length],
-					generatedLengths: [source.length],
-					data: {
-						verification: false,
-						completion: true,
-						semantic: true,
-						navigation: true,
-						structure: true,
-						format: true,
-						customData: {},
-					},
-				},
-			],
-			cssMappings: [],
-			errors: [],
-		};
-	},
-};
-`,
-	solid: `module.exports = {
-	compile_to_volar_mappings(source, filename) {
-		const code = \`/* compiler:solid */\\nexport const filename = \${JSON.stringify(filename)};\\nexport default \${JSON.stringify(source)};\`;
-		return {
-			code,
-			mappings: [
-				{
-					sourceOffsets: [0],
-					generatedOffsets: [0],
-					lengths: [source.length],
-					generatedLengths: [source.length],
-					data: {
-						verification: false,
-						completion: true,
-						semantic: true,
-						navigation: true,
-						structure: true,
-						format: true,
-						customData: {},
-					},
-				},
-			],
-			cssMappings: [],
-			errors: [],
-		};
-	},
-};
-`,
-	preact: `module.exports = {
-	compile_to_volar_mappings(source, filename) {
-		const code = \`/* compiler:preact */\\nexport const filename = \${JSON.stringify(filename)};\\nexport default \${JSON.stringify(source)};\`;
-		return {
-			code,
-			mappings: [
-				{
-					sourceOffsets: [0],
-					generatedOffsets: [0],
-					lengths: [source.length],
-					generatedLengths: [source.length],
-					data: {
-						verification: false,
-						completion: true,
-						semantic: true,
-						navigation: true,
-						structure: true,
-						format: true,
-						customData: {},
-					},
-				},
-			],
-			cssMappings: [],
-			errors: [],
-		};
-	},
-};
-`,
-};
-
-export const WORKSPACE_CONFIGS = {
-	'ripple-only': {
-		package_json: {
-			name: '@ripple-ts/fixture-ripple-only-project',
-			private: true,
-			devDependencies: {
-				'@tsrx/ripple': 'workspace:*',
-				'@ripple-ts/vite-plugin': 'workspace:*',
-				ripple: 'workspace:*',
-			},
-		},
-		compilers: ['ripple'],
-	},
-	'react-only': {
-		package_json: {
-			name: '@tsrx/fixture-react-only-project',
-			private: true,
-			devDependencies: {
-				'@tsrx/react': 'workspace:*',
-				'@tsrx/vite-plugin-react': 'workspace:*',
-			},
-		},
-		compilers: ['react'],
-	},
-	'solid-only': {
-		package_json: {
-			name: '@tsrx/fixture-solid-only-project',
-			private: true,
-			devDependencies: {
-				'@tsrx/solid': 'workspace:*',
-				'@tsrx/vite-plugin-solid': 'workspace:*',
-			},
-		},
-		compilers: ['solid'],
-	},
-	'preact-only': {
-		package_json: {
-			name: '@tsrx/fixture-preact-only-project',
-			private: true,
-			devDependencies: {
-				'@tsrx/preact': 'workspace:*',
-				'@tsrx/vite-plugin-preact': 'workspace:*',
-			},
-		},
-		compilers: ['preact'],
-	},
-	both: {
-		package_json: {
-			name: '@ripple-ts/fixture-ripple-project',
-			private: true,
-			devDependencies: {
-				'@tsrx/ripple': 'workspace:*',
-				'@ripple-ts/vite-plugin': 'workspace:*',
-				ripple: 'workspace:*',
-			},
-		},
-		compilers: ['ripple', 'react'],
-	},
-	'both-react': {
-		package_json: {
-			name: '@tsrx/fixture-react-project',
-			private: true,
-			devDependencies: {
-				'@tsrx/react': 'workspace:*',
-				'@tsrx/vite-plugin-react': 'workspace:*',
-			},
-		},
-		compilers: ['ripple', 'react'],
-	},
-	'both-preact': {
-		package_json: {
-			name: '@tsrx/fixture-preact-project',
-			private: true,
-			devDependencies: {
-				'@tsrx/preact': 'workspace:*',
-				'@tsrx/vite-plugin-preact': 'workspace:*',
-			},
-		},
-		compilers: ['ripple', 'react', 'solid', 'preact'],
-	},
-};
-
-/** @type {string[]} */
-const created_workspaces = [];
-
-/**
- * @param {string} workspace_dir
- * @param {keyof typeof COMPILER_STUBS} compiler_name
- */
-function write_compiler_stub(workspace_dir, compiler_name) {
-	const compiler_dir = path.join(workspace_dir, 'node_modules', '@tsrx', compiler_name, 'src');
-	fs.mkdirSync(compiler_dir, { recursive: true });
-	fs.writeFileSync(path.join(compiler_dir, 'index.js'), COMPILER_STUBS[compiler_name]);
-}
-
-/**
- * @param {keyof typeof WORKSPACE_CONFIGS} name
- */
-export function create_fixture_workspace(name) {
-	const config = WORKSPACE_CONFIGS[name];
-	if (!config) {
-		throw new Error(`Unknown fixture workspace: ${name}`);
-	}
-
-	const workspace_dir = fs.mkdtempSync(path.join(os.tmpdir(), `ts-plugin-${name}-`));
-	created_workspaces.push(workspace_dir);
-
-	fs.mkdirSync(path.join(workspace_dir, 'src', 'nested', 'components'), { recursive: true });
-	fs.writeFileSync(
-		path.join(workspace_dir, 'package.json'),
-		JSON.stringify(config.package_json, null, 2) + '\n',
-	);
-
-	for (const compiler_name of config.compilers) {
-		write_compiler_stub(workspace_dir, /** @type {keyof typeof COMPILER_STUBS} */ (compiler_name));
-	}
-
-	return workspace_dir;
-}
-
-export function cleanup_fixture_workspaces() {
-	while (created_workspaces.length > 0) {
-		fs.rmSync(/** @type {string} */ (created_workspaces.pop()), { recursive: true, force: true });
-	}
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "target": "esnext",
-    "lib": ["esnext"],
-    "allowJs": true,
-    "checkJs": true,
-    "noEmit": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "types": ["node"]
-  },
-  "include": ["./src/**/*", "./tests/**/*"],
-  "exclude": ["dist", "node_modules"]
-}

package/tsconfig.typecheck.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "skipLibCheck": true
-  },
-  "include": ["./src/**/*"],
-  "exclude": ["dist", "node_modules"]
-}