Commit d0f3e76

Plain JavaScript apps use the JavaScript helper and do not need `typescript` installed:

import { javascriptConfig } from '@nativescript/vite/javascript';

The TypeScript compiler is loaded only when a source needs the `@NativeClass` ES5 downlevel or when build-time type checking runs. If a plugin ships `@NativeClass`-decorated code and `typescript` is missing, the build logs a warning asking you to add `typescript` as a devDependency. Path aliases for JavaScript apps are read from `jsconfig.json` when there is no `tsconfig.json`.

import type * as TS from 'typescript';

import { loadTypeScript, warnNativeClassSkipped } from './typescript.js';

const ts = loadTypeScript();

if (!ts) {

// Note: can remove when https://github.com/NativeScript/ios/pull/403 lands.

// Might be worth a log or version detection on runtime version to ensure supported "nativeclass" runtime handling (without transformers).

warnNativeClassSkipped(fileName);

return null;

}

const transformer: TS.TransformerFactory<TS.SourceFile> = (ctx) => {

const visit: TS.Visitor = (node) => {

return ts.visitNode(node.arguments[1], visit) as TS.Expression;

return (node) => ts.visitNode(node, visit) as TS.SourceFile;

const res = ts.transform<TS.SourceFile>(sfJS, [transformer]);

const ts = loadTypeScript();

if (!ts) {

// Note: can remove when https://github.com/NativeScript/ios/pull/403 lands.

warnNativeClassSkipped(fileName);

return null;

}

const collect = (node: TS.Node) => {

const name = (node as TS.ClassDeclaration).name?.text;

import type * as TS from 'typescript';

import { loadTypeScript, warnNativeClassSkipped, type TypeScript } from './typescript.js';

function isNativeClassDecoratorElement(ts: TypeScript, el: TS.Expression): boolean {

function collectNativeClassDecorateEdits(ts: TypeScript, code: string, sf: TS.SourceFile): { edits: Array<{ start: number; end: number; text: string }>; classNames: Set<string> } {

const visit = (node: TS.Node): void => {

const remaining = firstArg.elements.filter((el) => !isNativeClassDecoratorElement(ts, el));

function stripExtendsImportFromTslib(ts: TypeScript, code: string): string {

let sf: TS.SourceFile;

if (!code.includes('__decorate') || !/\bNativeClass\b/.test(code)) return null;

const ts = loadTypeScript();

if (!ts) {

warnNativeClassSkipped(bareId);

return null;

}

let sf: TS.SourceFile;

const { edits: decorateEdits, classNames: classNamesToDownlevel } = collectNativeClassDecorateEdits(ts, code, sf);

let classNode: TS.ClassExpression | TS.ClassDeclaration | undefined;

const findClass = (node: TS.Node) => {

output = stripExtendsImportFromTslib(ts, output);

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

vi.mock('./typescript.js', async (importOriginal) => {

const actual = await importOriginal<typeof import('./typescript.js')>();

return { ...actual, loadTypeScript: () => null };

import { transformNativeClassSource } from './nativeclass-transform.js';

import { postCleanupNativeClass } from './nativeclass-transformer-plugin.js';

const DECORATED_TS = `

const DECORATED_JS = `

describe('NativeClass transforms when typescript is not installed', () => {

let warn: ReturnType<typeof vi.spyOn>;

beforeEach(() => {

warn = vi.spyOn(console, 'warn').mockImplementation(() => {});

});

afterEach(() => {

warn.mockRestore();

});

it('stays silent for sources that never needed the compiler', () => {

expect(transformNativeClassSource('export const x = 1;', '/app/x.js')).toBeNull();

expect(transformNativeClassSource('function ensureNativeClasses() {}', '/app/core.js')).toBeNull();

expect(transformNativeClassSource('const Foo = __decorate([Component()], Foo);', '/app/foo.js')).toBeNull();

expect(postCleanupNativeClass('export const x = 1;', '/app/x')).toBeNull();

expect(postCleanupNativeClass('function ensureNativeClasses() {}\nlet Foo = __decorate([Component()], Foo);', '/app/core')).toBeNull();

expect(warn).not.toHaveBeenCalled();

});

it('leaves decorated sources untouched and warns once', () => {

expect(transformNativeClassSource(DECORATED_TS, '/app/timer.ts')).toBeNull();

expect(transformNativeClassSource(DECORATED_JS, '/node_modules/plugin/index.js')).toBeNull();

expect(postCleanupNativeClass(DECORATED_JS, '/node_modules/plugin/index')).toBeNull();

expect(warn).toHaveBeenCalledTimes(1);

expect(String(warn.mock.calls[0][0])).toContain('/app/timer.ts');

expect(String(warn.mock.calls[0][0])).toContain("'typescript'");

});

import { afterEach, describe, expect, it, vi } from 'vitest';

import { createTsConfigPathsResolver, getTsConfigAliasRoots, getTsConfigData } from './ts-config-paths.js';

describe('getTsConfigData', () => {

const cwd = process.cwd();

function createProject(): { root: string; realRoot: string } {

const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ns-tsconfig-data-'));

tempDirs.push(root);

return { root, realRoot: fs.realpathSync(root) };

}

afterEach(() => {

process.chdir(cwd);

});

it('reads path aliases from jsconfig.json when the project has no tsconfig', () => {

const { root, realRoot } = createProject();

fs.writeFileSync(path.join(root, 'jsconfig.json'), JSON.stringify({ compilerOptions: { baseUrl: './', paths: { '~/*': ['app/*'] } } }));

process.chdir(root);

expect(getTsConfigData({ platform: 'ios' }).paths).toEqual({ '~/*': [path.join(realRoot, 'app', '*')] });

});

it('prefers tsconfig.json over jsconfig.json', () => {

const { root, realRoot } = createProject();

fs.writeFileSync(path.join(root, 'tsconfig.json'), JSON.stringify({ compilerOptions: { paths: { '@ts/*': ['src/*'] } } }));

fs.writeFileSync(path.join(root, 'jsconfig.json'), JSON.stringify({ compilerOptions: { paths: { '@js/*': ['app/*'] } } }));

process.chdir(root);

expect(getTsConfigData({ platform: 'ios' }).paths).toEqual({ '@ts/*': [path.join(realRoot, 'src', '*')] });

});

it('returns no aliases without warning when the project has neither file', () => {

const { root } = createProject();

process.chdir(root);

const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});

try {

expect(getTsConfigData({ platform: 'ios' })).toEqual({ paths: {}, baseUrl: '.' });

expect(warn).not.toHaveBeenCalled();

} finally {

warn.mockRestore();

}

});

function getTsConfigPaths(tsConfigPath: string, debugViteLogs: boolean = false) {

// jsconfig.json is where a plain JavaScript app keeps the same `paths` aliases.

const candidatePath = ['tsconfig.app.json', 'tsconfig.json', 'jsconfig.json'].map(getProjectFilePath).find((candidate) => fs.existsSync(candidate)) ?? null;

cachedConfig = candidatePath ? getTsConfigPaths(candidatePath, verbose) : { paths: {}, baseUrl: '.' };

console.log(candidatePath ? '📁 Loaded TypeScript path configuration' : '📁 No tsconfig.json or jsconfig.json found; no path aliases configured');