@tamagui/build 2.0.0-rc.3 → 2.0.0-rc.30

package/.turbo/turbo-test.log

@@ -5,31 +5,113 @@ $ vitest --run
 $ node ../../../tamagui-build.js
 $ node ../../../tamagui-build.js --bundle
 $ node ../../../tamagui-build.js --skip-mjs
+$ node ../../../tamagui-build.js --skip-sourcemaps
 $ node ../../../tamagui-build.js --ignore-base-url
 stdout | __tests__/integration.test.ts > tamagui-build integration test > should rebuild the package on file change when --watch is used
-Watch process output: built tamagui-build-test-watch-package in 78 ms
+Watch process output: built tamagui-build-test-watch-package in 79 ms
 
 Initial build complete, modifying file...
 
 stdout | __tests__/integration.test.ts > tamagui-build integration test > should rebuild the package on file change when --watch is used
-Watch process output: built tamagui-build-test-watch-package in 335 ms
+Watch process output: built tamagui-build-test-watch-package in 348 ms
 
 Rebuild after file modification complete
 
 $ node ../../../tamagui-build.js
 $ node ../../../tamagui-build.js
 $ MINIFY=true node ../../../tamagui-build.js
- ✓ __tests__/integration.test.ts (7 tests) 5051ms
-     ✓ should build the package correctly  608ms
-     ✓ should bundle the package correctly  539ms
-     ✓ should skip mjs files when --skip-mjs is used  606ms
-     ✓ should ignore base URL when --ignore-base-url is used  582ms
-     ✓ should rebuild the package on file change when --watch is used  929ms
-     ✓ should generate correct platform-specific output  584ms
-     ✓ should minify the output when MINIFY=true is set  1182ms
-
- Test Files  1 passed (1)
-      Tests  7 passed (7)
-   Start at  13:57:06
-   Duration  5.16s (transform 37ms, setup 0ms, collect 43ms, tests 5.05s, environment 0ms, prepare 2ms)
+$ node ../../../tamagui-build.js
+$ node ../../../tamagui-build.js
+$ node ../../../tamagui-build.js
+$ node ../../../tamagui-build.js
+ ❯ __tests__/integration.test.ts (11 tests | 4 failed) 8732ms
+     × should build the package correctly 647ms
+     × should bundle the package correctly 549ms
+     × should skip mjs files when --skip-mjs is used 611ms
+     ✓ should skip sourcemaps when --skip-sourcemaps is used  620ms
+     ✓ should ignore base URL when --ignore-base-url is used  621ms
+     ✓ should rebuild the package on file change when --watch is used  752ms
+     ✓ should generate correct platform-specific output  617ms
+     ✓ should minify the output when MINIFY=true is set  1267ms
+     ✓ should clean stale outputs before building  1250ms
+     × should keep only the required js aliases after postprocessing 631ms
+     ✓ should keep explicit cjs .js mains as final output  1133ms
+
+⎯⎯⎯⎯⎯⎯⎯ Failed Tests 4 ⎯⎯⎯⎯⎯⎯⎯
+
+ FAIL  __tests__/integration.test.ts > tamagui-build integration test > should build the package correctly
+AssertionError: expected false to be true // Object.is equality
+
+- Expected
++ Received
+
+- true
++ false
+
+ ❯ __tests__/integration.test.ts:50:59
+     48|     expect(esmOutput).toContain('Hello,')
+     49|     expect(esmOutput).toContain("./nested/index.mjs")
+     50|     expect(existsSync(join(distPath, 'cjs', 'index.js'))).toBe(true)
+       |                                                           ^
+     51|     expect(existsSync(join(distPath, 'esm', 'index.js'))).toBe(true)
+     52|     expect(existsSync(join(distPath, 'jsx', 'index.js'))).toBe(true)
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/4]⎯
+
+ FAIL  __tests__/integration.test.ts > tamagui-build integration test > should bundle the package correctly
+AssertionError: expected false to be true // Object.is equality
+
+- Expected
++ Received
+
+- true
++ false
+
+ ❯ __tests__/integration.test.ts:67:59
+     65|     expect(cjsOutput).toContain('Hello,')
+     66|     expect(esmOutput).toContain('Hello,')
+     67|     expect(existsSync(join(distPath, 'cjs', 'index.js'))).toBe(true)
+       |                                                           ^
+     68|     expect(existsSync(join(distPath, 'esm', 'index.js'))).toBe(true)
+     69|     expect(existsSync(join(distPath, 'jsx', 'index.js'))).toBe(true)
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/4]⎯
+
+ FAIL  __tests__/integration.test.ts > tamagui-build integration test > should skip mjs files when --skip-mjs is used
+AssertionError: expected false to be true // Object.is equality
+
+- Expected
++ Received
+
+- true
++ false
+
+ ❯ __tests__/integration.test.ts:79:59
+     77|     expect(existsSync(distCjsFilePath)).toBe(true)
+     78|     expect(existsSync(distEsmFilePath)).toBe(false)
+     79|     expect(existsSync(join(distPath, 'cjs', 'index.js'))).toBe(true)
+       |                                                           ^
+     80|   })
+     81| 
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/4]⎯
+
+ FAIL  __tests__/integration.test.ts > tamagui-build integration test > should keep only the required js aliases after postprocessing
+AssertionError: expected [ 'cjs/index.cjs', …(25) ] to include 'cjs/index.js'
+ ❯ __tests__/integration.test.ts:250:23
+    248|       .map((file) => file.replace(/^dist\//, ''))
+    249| 
+    250|     expect(distFiles).toContain('cjs/index.js')
+       |                       ^
+    251|     expect(distFiles).toContain('esm/index.js')
+    252|     expect(distFiles).toContain('esm/index.js.map')
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[4/4]⎯
+
+
+ Test Files  1 failed (1)
+      Tests  4 failed | 7 passed (11)
+   Start at  17:18:05
+   Duration  8.85s (transform 35ms, setup 0ms, collect 42ms, tests 8.73s, environment 0ms, prepare 3ms)
 
+error: script "test" exited with code 1

package/README.md

@@ -14,7 +14,7 @@ Some details on how it works:
   - in `.mjs`, adds path-specific imports to non-specific imports
 - outputs both `.js` and `.cjs` files in `dist/cjs`:
   - in `.cjs`, adds path-specific imports to non-specific imports
-- removes hanging imports that esbuild leaves (see `pkgRemoveSideEffects`)
+- strips bare imports that esbuild leaves behind, respecting the `sideEffects` field in package.json
 - outputs `.native.js` and regular `.js` files for all output files, so React Native always loads separate files from web. In the `native` specific files,
   - swc is sued to transform to es5
   - `process.env.TAMAGUI_TARGET` is defined `native` (otherwise `web`)
@@ -30,7 +30,6 @@ It assumes your package.json looks something like this:
   "main": "dist/cjs",
   "module": "dist/esm",
   "type": "module",
-  "removeSideEffects": "true",
   "scripts": {
     "build": "tamagui-build",
     "watch": "tamagui-build --watch",
@@ -69,12 +68,15 @@ It assumes your package.json looks something like this:
 ### Use
 
 - `tamagui-build` - builds `src` folder to `dist` and `types` folders
+  - normal builds clear `dist` and `types` first, so stale transformed files don't hang around
+  - intermediary `.js` files are removed after `.mjs` / `.cjs` postprocessing, so published output stays lean
   - `tamagui build .` second argument sets baseUrl to tsc
   - `--bundle-modules` - inline node_modules
   - `--declaration-root` - sets tsc flag `--declarationDir ./`
   - `--ignore-base-url` - if not set, tsc is passed `--baseUrl .`
   - `--skip-mjs` - don't output mjs files
   - `--skip-native` - don't output native files
+  - `--skip-sourcemaps` - don't output js or declaration sourcemaps
   - `--swap-exports` - swaps `exports.types` from `./src/*.ts` to `./types/*.d.ts` for publishing. if a command is given after `--`, runs it then swaps back. exit code is preserved.
     - `tamagui-build --swap-exports` - build and swap, stays swapped (for manual publish)
     - `tamagui-build --swap-exports -- npm publish` - build, swap, publish, swap back

package/__tests__/fixtures/js-main-package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+$ node ../../../tamagui-build.js
+built tamagui-build-test-js-main-package in 5670 ms

package/__tests__/fixtures/js-main-package/LICENSE

@@ -0,0 +1 @@
+MIT

package/__tests__/fixtures/js-main-package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var index_exports = {};
+__export(index_exports, {
+  jsMainFixture: () => jsMainFixture
+});
+module.exports = __toCommonJS(index_exports);
+const jsMainFixture = "ok";
+//# sourceMappingURL=index.js.map

package/__tests__/fixtures/js-main-package/dist/cjs/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,gBAAgB;",
+  "names": []
+}

package/__tests__/fixtures/js-main-package/dist/cjs/index.native.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var index_exports = {};
+__export(index_exports, {
+  jsMainFixture: () => jsMainFixture
+});
+module.exports = __toCommonJS(index_exports);
+var jsMainFixture = "ok";
+//# sourceMappingURL=index.native.js.map

package/__tests__/fixtures/js-main-package/dist/cjs/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","index_exports","__export","jsMainFixture","module","exports"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,aAAA;AAAAC,QAAA,CAAAD,aAAA;EAAAE,aAAA,EAAAA,CAAA,KAAAA;AAAA;AAAOC,MAAM,CAAAC,OAAA,GAAAT,YAAgB,CAAAK,aAAA","ignoreList":[]}

package/__tests__/fixtures/js-main-package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+const jsMainFixture = "ok";
+export { jsMainFixture };
+//# sourceMappingURL=index.mjs.map

package/__tests__/fixtures/js-main-package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["jsMainFixture"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAO,MAAMA,aAAA,GAAgB","ignoreList":[]}

package/__tests__/fixtures/js-main-package/dist/esm/index.native.js

@@ -0,0 +1,3 @@
+var jsMainFixture = "ok";
+export { jsMainFixture };
+//# sourceMappingURL=index.native.js.map

package/__tests__/fixtures/js-main-package/dist/esm/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["jsMainFixture"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAO,IAAAA,aAAM,OAAgB","ignoreList":[]}

package/__tests__/fixtures/js-main-package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "tamagui-build-test-js-main-package",
+  "version": "2.0.0-rc.0-1769885482630",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.mjs",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "build": "node ../../../tamagui-build.js"
+  },
+  "devDependencies": {
+    "@tamagui/build": "workspace:*",
+    "typescript": "~5.9.2"
+  }
+}

package/__tests__/fixtures/js-main-package/src/index.ts

@@ -0,0 +1 @@
+export const jsMainFixture = 'ok'

package/__tests__/fixtures/js-main-package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "declaration": true,
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/__tests__/fixtures/js-main-package/types/index.d.ts

@@ -0,0 +1,2 @@
+export declare const jsMainFixture = "ok";
+//# sourceMappingURL=index.d.ts.map

package/__tests__/fixtures/js-main-package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,OAAO,CAAA"}

package/__tests__/fixtures/simple-package/.turbo/turbo-build.log

@@ -1,2 +1,2 @@
 $ node ../../../tamagui-build.js
-built tamagui-build-test-simple-tpackage in 992 ms
+built tamagui-build-test-simple-tpackage in 3496 ms

package/__tests__/fixtures/simple-package/package.json

@@ -2,12 +2,14 @@
   "name": "tamagui-build-test-simple-tpackage",
   "version": "2.0.0-rc.0-1769885482630",
   "main": "dist/cjs",
-  "module": "dist/esm/index.mjs",
+  "module": "dist/esm",
+  "module:jsx": "dist/jsx",
   "types": "dist/types/index.d.ts",
   "scripts": {
     "build": "node ../../../tamagui-build.js",
     "build:bundle": "node ../../../tamagui-build.js --bundle",
     "build:skip-mjs": "node ../../../tamagui-build.js --skip-mjs",
+    "build:skip-sourcemaps": "node ../../../tamagui-build.js --skip-sourcemaps",
     "build:declaration-root": "node ../../../tamagui-build.js --declaration-root",
     "build:ignore-base-url": "node ../../../tamagui-build.js --ignore-base-url",
     "build:watch": "node ../../../tamagui-build.js --watch",

package/__tests__/fixtures/simple-package/src/index.ts

@@ -1,3 +1,5 @@
+export { nestedHello } from './nested'
+
 export const greet = (name: string): string => {
   return `Hello, ${name}!`
 }

package/__tests__/fixtures/simple-package/src/nested/index.ts

@@ -0,0 +1 @@
+export const nestedHello = 'nested hello'

package/__tests__/fixtures/watch-package/.turbo/turbo-build.log

@@ -1,2 +1,2 @@
 $ node ../../../tamagui-build.js
-built tamagui-build-test-watch-package in 1028 ms
+built tamagui-build-test-watch-package in 2561 ms

package/__tests__/integration.test.ts

@@ -1,5 +1,5 @@
 import { execSync, spawn } from 'node:child_process'
-import { existsSync, readFileSync, writeFileSync, statSync } from 'node:fs'
+import { existsSync, readFileSync, writeFileSync, statSync, readdirSync } from 'node:fs'
 import { describe, it, expect, beforeAll, afterAll } from 'vitest'
 import { join } from 'node:path'
 import { readFile } from 'node:fs/promises'
@@ -15,6 +15,8 @@ const distCjsFilePath = join(distPath, 'cjs', 'index.cjs')
 const watchDistCjsFilePath = join(watchDistPath, 'cjs', 'watch.cjs')
 const distEsmFilePath = join(distPath, 'esm', 'index.mjs')
 const distTypesFilePath = join(simplePackagePath, 'types', 'index.d.ts')
+const jsMainPackagePath = join(__dirname, 'fixtures', 'js-main-package')
+const jsMainDistPath = join(jsMainPackagePath, 'dist')
 // console.log({
 //   distCjsFilePath,
 //   distEsmFilePath,
@@ -28,6 +30,7 @@ describe('tamagui-build integration test', () => {
   beforeAll(() => {
     // Clean up dist directory before starting
     execSync('rm -rf dist && rm -rf types', { cwd: simplePackagePath })
+    execSync('rm -rf dist && rm -rf types', { cwd: jsMainPackagePath })
   })
 
   it('should build the package correctly', () => {
@@ -43,6 +46,10 @@ describe('tamagui-build integration test', () => {
     const esmOutput = readFileSync(distEsmFilePath, 'utf-8')
     expect(cjsOutput).toContain('Hello,')
     expect(esmOutput).toContain('Hello,')
+    expect(esmOutput).toContain("./nested/index.mjs")
+    expect(existsSync(join(distPath, 'cjs', 'index.cjs'))).toBe(true)
+    expect(existsSync(join(distPath, 'esm', 'index.js'))).toBe(true)
+    expect(existsSync(join(distPath, 'jsx', 'index.js'))).toBe(true)
   })
 
   it('should bundle the package correctly', () => {
@@ -57,6 +64,9 @@ describe('tamagui-build integration test', () => {
     const esmOutput = readFileSync(distEsmFilePath, 'utf-8')
     expect(cjsOutput).toContain('Hello,')
     expect(esmOutput).toContain('Hello,')
+    expect(existsSync(join(distPath, 'cjs', 'index.cjs'))).toBe(true)
+    expect(existsSync(join(distPath, 'esm', 'index.js'))).toBe(true)
+    expect(existsSync(join(distPath, 'jsx', 'index.js'))).toBe(true)
   })
 
   it('should skip mjs files when --skip-mjs is used', () => {
@@ -66,6 +76,27 @@ describe('tamagui-build integration test', () => {
     // Check if the output files exist
     expect(existsSync(distCjsFilePath)).toBe(true)
     expect(existsSync(distEsmFilePath)).toBe(false)
+    expect(existsSync(join(distPath, 'cjs', 'index.cjs'))).toBe(true)
+  })
+
+  it('should skip sourcemaps when --skip-sourcemaps is used', () => {
+    execSync('rm -rf dist && rm -rf types', { cwd: simplePackagePath })
+    execSync('bun run build:skip-sourcemaps', { cwd: simplePackagePath })
+
+    expect(existsSync(distCjsFilePath)).toBe(true)
+    expect(existsSync(distEsmFilePath)).toBe(true)
+    expect(existsSync(distTypesFilePath)).toBe(true)
+    expect(existsSync(join(distPath, 'cjs', 'index.cjs.map'))).toBe(false)
+    expect(existsSync(join(distPath, 'esm', 'index.mjs.map'))).toBe(false)
+    expect(existsSync(join(simplePackagePath, 'types', 'index.d.ts.map'))).toBe(false)
+
+    const cjsOutput = readFileSync(distCjsFilePath, 'utf-8')
+    const esmOutput = readFileSync(distEsmFilePath, 'utf-8')
+    const typesOutput = readFileSync(distTypesFilePath, 'utf-8')
+
+    expect(cjsOutput).not.toContain('sourceMappingURL=')
+    expect(esmOutput).not.toContain('sourceMappingURL=')
+    expect(typesOutput).not.toContain('sourceMappingURL=')
   })
 
   it('should ignore base URL when --ignore-base-url is used', () => {
@@ -183,12 +214,60 @@ describe('tamagui-build integration test', () => {
     expect(esmOutput).not.toMatch(/^\s+$/m) // No lines with only whitespace
 
     // Check that the number of lines is reduced
-    expect(cjsOutput.split('\n').length).toBeLessThan(32)
-    expect(esmOutput.split('\n').length).toBeLessThan(32)
+    expect(cjsOutput.split('\n').length).toBeLessThan(originalCjsSize > 0 ? 40 : 32)
+    expect(esmOutput.split('\n').length).toBeLessThan(originalEsmSize > 0 ? 40 : 32)
+  })
+
+  it('should clean stale outputs before building', () => {
+    execSync('bun run build', { cwd: simplePackagePath })
+
+    const staleFilePath = join(distPath, 'esm', 'stale.mjs')
+    const staleTypesPath = join(simplePackagePath, 'types', 'stale.d.ts')
+    writeFileSync(staleFilePath, 'stale')
+    writeFileSync(staleTypesPath, 'stale')
+
+    expect(existsSync(staleFilePath)).toBe(true)
+    expect(existsSync(staleTypesPath)).toBe(true)
+
+    execSync('bun run build', { cwd: simplePackagePath })
+
+    expect(existsSync(staleFilePath)).toBe(false)
+    expect(existsSync(staleTypesPath)).toBe(false)
+    expect(readdirSync(join(distPath, 'esm'))).not.toContain('stale.mjs')
+  })
+
+  it('should keep only the required js aliases after postprocessing', () => {
+    execSync('bun run build', { cwd: simplePackagePath })
+
+    const distFiles = execSync('find dist -type f | sort', {
+      cwd: simplePackagePath,
+      encoding: 'utf-8',
+    })
+      .trim()
+      .split('\n')
+      .map((file) => file.replace(/^dist\//, ''))
+
+    expect(distFiles).toContain('cjs/index.cjs')
+    expect(distFiles).toContain('esm/index.js')
+    expect(distFiles).toContain('esm/index.js.map')
+    expect(distFiles).toContain('jsx/index.js')
+    expect(distFiles).toContain('jsx/index.js.map')
+    expect(distFiles).toContain('cjs/index.cjs')
+    expect(distFiles).toContain('esm/index.mjs')
+    expect(distFiles).toContain('esm/nested/index.mjs')
+  })
+
+  it('should keep explicit cjs .js mains as final output', () => {
+    execSync('bun run build', { cwd: jsMainPackagePath })
+
+    expect(existsSync(join(jsMainDistPath, 'cjs', 'index.js'))).toBe(true)
+    expect(existsSync(join(jsMainDistPath, 'cjs', 'index.mjs'))).toBe(false)
+    expect(existsSync(join(jsMainDistPath, 'esm', 'index.mjs'))).toBe(true)
   })
 
   afterAll(() => {
     // Clean up dist directory after tests
     execSync('rm -rf dist && rm -rf types', { cwd: simplePackagePath })
+    execSync('rm -rf dist && rm -rf types', { cwd: jsMainPackagePath })
   })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/build",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.30",
   "gitHead": "a49cc7ea6b93ba384e77a4880ae48ac4a5635c14",
   "bin": {
     "tamagui-build": "tamagui-build.js",
@@ -10,27 +10,34 @@
     "access": "public"
   },
   "scripts": {
-    "test": "vitest --run"
+    "test": "vitest --run",
+    "test:web": "bun run test"
   },
   "dependencies": {
     "@babel/core": "^7.25.2",
     "@babel/preset-typescript": "^7.26.0",
     "@swc/core": "^1.14.0",
-    "@tamagui/babel-plugin-fully-specified": "2.0.0-rc.3",
+    "@tamagui/babel-plugin-fully-specified": "2.0.0-rc.30",
     "@types/fs-extra": "^9.0.13",
-    "babel-plugin-react-compiler": "^1.0.0",
     "baseline-browser-mapping": "^2.9.15",
     "chokidar": "^3.5.2",
     "esbuild": "^0.27.2",
-    "esbuild-plugin-es5": "^2.1.1",
     "esbuild-register": "^3.6.0",
     "execa": "^5.0.0",
     "fast-glob": "^3.2.11",
     "fs-extra": "^11.2.0",
     "lodash.debounce": "^4.0.8",
-    "oxc-transform": "^0.95.0",
+    "oxc-transform": "^0.112.0",
     "typescript": "~5.9.2"
   },
+  "peerDependencies": {
+    "babel-plugin-react-compiler": ">=1"
+  },
+  "peerDependenciesMeta": {
+    "babel-plugin-react-compiler": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "vitest": "4.0.4"
   }

package/pretty-print-errors.js

@@ -125,9 +125,42 @@ function printTypescriptCompilationError(err, packageName) {
   console.error('')
 }
 
+/**
+ * Pretty print OXC isolated declaration errors
+ * @param {Array<{ severity: string, message: string, labels: Array<{ message: string | null, start: number, end: number }>, helpMessage: string | null, codeframe: string | null }>} errors
+ */
+function printOxcErrors(errors) {
+  console.error('\n❌ Type declaration generation errors:\n')
+
+  errors.forEach((error) => {
+    const severity = error.severity === 'Error' ? '❌' : '⚠️ '
+    console.error(`  ${severity} ${error.message}`)
+
+    if (error.labels && error.labels.length > 0) {
+      error.labels.forEach((label) => {
+        console.error(`     at ${label.start}-${label.end}`)
+        if (label.message) {
+          console.error(`       ${label.message}`)
+        }
+      })
+    }
+
+    if (error.helpMessage) {
+      console.error(`     help: ${error.helpMessage}`)
+    }
+
+    if (error.codeframe) {
+      console.error(`\n${error.codeframe}`)
+    }
+  })
+
+  console.error('')
+}
+
 module.exports = {
   printTypescriptDiagnostics,
   printEsbuildError,
   printBuildError,
   printTypescriptCompilationError,
+  printOxcErrors,
 }

package/tamagui-build.js

@@ -9,6 +9,7 @@
  *   tamagui-build --watch             # watch mode
  *   tamagui-build --skip-types        # js only
  *   tamagui-build --skip-native       # skip native builds
+ *   tamagui-build --skip-sourcemaps   # disable js + d.ts sourcemaps
  *   tamagui-build clean               # remove dist/types/node_modules
  *   tamagui-build clean:build         # remove dist/types only
  *
@@ -38,6 +39,7 @@ const {
   printEsbuildError,
   printBuildError,
   printTypescriptCompilationError,
+  printOxcErrors,
 } = require('./pretty-print-errors')
 
 const jsOnly = !!process.env.JS_ONLY
@@ -45,12 +47,34 @@ const skipJS = !!(process.env.SKIP_JS || false)
 
 // write file only if contents changed to avoid triggering watchers
 async function writeIfUnchanged(filePath, contents) {
+  const isExecutableScript = typeof contents === 'string' && contents.startsWith('#!')
   const existing = await FSE.readFile(filePath, 'utf8').catch(() => null)
-  if (existing === contents) return false
-  await FSE.outputFile(filePath, contents, 'utf8')
+  if (existing === contents) {
+    if (isExecutableScript) {
+      await FSE.chmod(filePath, 0o755).catch(() => {})
+    }
+    return false
+  }
+  await FSE.outputFile(filePath, contents, {
+    encoding: 'utf8',
+    mode: isExecutableScript ? 0o755 : 0o666,
+  })
+  if (isExecutableScript) {
+    await FSE.chmod(filePath, 0o755).catch(() => {})
+  }
   return true
 }
 
+function hasFlag(flag) {
+  return process.argv.includes(flag)
+}
+
+function getEnvFlag(name) {
+  const value = process.env[name]
+  if (!value) return false
+  return !['0', 'false', 'no', 'off'].includes(String(value).toLowerCase())
+}
+
 /**
  * esbuild plugin that runs React Compiler on TS/TSX files before transformation
  */
@@ -105,32 +129,34 @@ const reactCompilerPlugin = {
   },
 }
 
-const shouldSwapExports = process.argv.includes('--swap-exports')
+const shouldSwapExports = hasFlag('--swap-exports')
 
 // when swapping exports for publish, we MUST build types (ignore --skip-types)
 const shouldSkipTypes = shouldSwapExports
   ? false
-  : !!(process.argv.includes('--skip-types') || process.env.SKIP_TYPES)
+  : !!(hasFlag('--skip-types') || process.env.SKIP_TYPES)
 
-const shouldSkipNative = !!process.argv.includes('--skip-native')
-const shouldSkipMJS = !!process.argv.includes('--skip-mjs')
+const shouldSkipNative = hasFlag('--skip-native')
+const shouldSkipMJS = hasFlag('--skip-mjs')
+const shouldSkipSourceMaps =
+  hasFlag('--skip-sourcemaps') || getEnvFlag('TAMAGUI_BUILD_SKIP_SOURCEMAPS')
 // React Compiler is disabled by default - use --react-compiler to enable
 const shouldEnableCompiler = !!(
-  process.argv.includes('--react-compiler') || process.env.REACT_COMPILER
+  hasFlag('--react-compiler') || process.env.REACT_COMPILER
 )
-const shouldBundleFlag = !!process.argv.includes('--bundle')
-const shouldBundleNodeModules = !!process.argv.includes('--bundle-modules')
+const shouldBundleFlag = hasFlag('--bundle')
+const shouldBundleNodeModules = hasFlag('--bundle-modules')
 const shouldClean = !!process.argv.includes('clean')
 const shouldCleanBuildOnly = !!process.argv.includes('clean:build')
-const shouldWatch = process.argv.includes('--watch')
+const shouldWatch = hasFlag('--watch')
 
 // get command after "--" to run with swapped exports
 const dashDashIndex = process.argv.indexOf('--')
 const runCommandAfterSwap =
   dashDashIndex > -1 ? process.argv.slice(dashDashIndex + 1) : null
 
-const declarationToRoot = !!process.argv.includes('--declaration-root')
-const ignoreBaseUrl = process.argv.includes('--ignore-base-url')
+const declarationToRoot = hasFlag('--declaration-root')
+const ignoreBaseUrl = hasFlag('--ignore-base-url')
 const baseUrlIndex = process.argv.indexOf('--base-url')
 const tsProjectIndex = process.argv.indexOf('--ts-project')
 const exludeIndex = process.argv.indexOf('--exclude')
@@ -153,7 +179,6 @@ const pkgSource = pkg.source
 const pkgModule = pkg.module
 const pkgModuleJSX = pkg['module:jsx']
 const pkgTypes = Boolean(pkg.types || pkg.typings)
-const pkgRemoveSideEffects = pkg.removeSideEffects || false
 
 // build config from package.json
 const buildConfig = pkg['tamagui-build'] || {}
@@ -166,6 +191,20 @@ const bundleExternal = buildConfig.bundleExternal || null
 const flatOut = [pkgMain, pkgModule, pkgModuleJSX].filter(Boolean).length === 1
 
 const avoidCJS = pkgMain?.endsWith('.js')
+const getJsEntryAliasPath = (entry) => {
+  if (!entry) return null
+  if (!path.extname(entry)) {
+    return path.join(entry, 'index.js').replace(/\\/g, '/')
+  }
+  if (entry.endsWith('.js')) {
+    return entry.replace(/\\/g, '/')
+  }
+  return null
+}
+const cjsMainAliasPath = getJsEntryAliasPath(pkgMain)
+const esmAliasPaths = [getJsEntryAliasPath(pkgModule), getJsEntryAliasPath(pkgModuleJSX)].filter(
+  Boolean
+)
 
 const replaceRNWeb = {
   esm: (content) =>
@@ -236,13 +275,14 @@ if (shouldClean || shouldCleanBuildOnly) {
   if (shouldWatch) {
     process.env.IS_WATCHING = true
     process.env.DISABLE_AUTORUN = true
-    const rebuild = debounce(build, 100)
+    const rebuild = debounce(() => build({ cleanOutput: false }), 100)
     const chokidar = require('chokidar')
 
     if (!process.env.SKIP_INITIAL_BUILD) {
       // do one js build but not types
       build({
         skipTypes: true,
+        cleanOutput: true,
       })
     }
 
@@ -365,10 +405,18 @@ function swapExportsTypes(pkg, direction) {
   return swapped
 }
 
-async function build({ skipTypes } = {}) {
+async function build({ skipTypes, cleanOutput = !shouldWatch } = {}) {
   if (process.env.DEBUG) console.info('🔹', pkg.name)
   try {
     const start = Date.now()
+    const isSkippingTypesForBuild = Boolean(skipTypes || shouldSkipTypes || !pkgTypes)
+
+    if (cleanOutput) {
+      await Promise.allSettled([
+        FSE.remove('dist'),
+        isSkippingTypesForBuild ? null : FSE.remove('types'),
+      ])
+    }
 
     const allFiles = (await fastGlob(['src/**/*.(m)?[jt]s(x)?', 'src/**/*.css'])).filter(
       (x) => !x.includes('.d.ts') && (exclude ? !x.match(exclude) : true)
@@ -441,29 +489,48 @@ async function buildTsc(allFiles) {
     const compilerOptions = createCompilerOptions(config.options, targetDir)
 
     if (config.options.isolatedDeclarations) {
-      const oxc = require('oxc-transform')
+      const oxc = await import('oxc-transform')
 
-      await Promise.all(
+      const results = await Promise.all(
         allFiles.map(async (file) => {
           const source = await FSE.readFile(file, 'utf-8')
-          const { code, map } = oxc.isolatedDeclaration(file, source, {
-            sourcemap: true,
+          const { code, map, errors } = await oxc.isolatedDeclaration(file, source, {
+            sourcemap: !shouldSkipSourceMaps,
           })
 
+          if (errors && errors.length > 0) {
+            return errors
+          }
+
           const dtsPath = path
             .join(`types`, ...file.split('/').slice(1))
             .replace(/\.tsx?$/, '.d.ts')
           const mapPath = `${dtsPath}.map`
 
-          const output = `${code}\n//# sourceMappingURL=${path.basename(mapPath)}`
+          const output = shouldSkipSourceMaps
+            ? code
+            : `${code}\n//# sourceMappingURL=${path.basename(mapPath)}`
           await FSE.ensureDir(dirname(dtsPath))
-          await Promise.all([
-            writeIfUnchanged(dtsPath, output),
-            writeIfUnchanged(mapPath, JSON.stringify(map, null, 2)),
-          ])
+          await writeIfUnchanged(dtsPath, output)
+          if (!shouldSkipSourceMaps && map) {
+            await writeIfUnchanged(mapPath, JSON.stringify(map, null, 2))
+          } else {
+            await FSE.remove(mapPath)
+          }
+
+          return []
         })
       )
 
+      const allErrors = results.flat()
+
+      if (allErrors.length > 0) {
+        printOxcErrors(allErrors)
+        if (!shouldWatch) {
+          process.exit(1)
+        }
+      }
+
       return
     }
 
@@ -540,7 +607,7 @@ function createCompilerOptions(baseOptions, targetDir) {
     ...baseOptions,
     declaration: true,
     emitDeclarationOnly: true,
-    declarationMap: true,
+    declarationMap: !shouldSkipSourceMaps,
     outDir: targetDir,
     rootDir: 'src',
     incremental: true,
@@ -701,6 +768,8 @@ async function buildJs(allFiles) {
           platform: 'web',
           bundle: shouldBundleFlag,
           specifyCJS: !avoidCJS,
+          keepJsOutput: avoidCJS,
+          preserveJsPaths: [],
         })
       : null,
 
@@ -716,6 +785,7 @@ async function buildJs(allFiles) {
       ? esbuildWriteIfChanged(esmConfig, {
           platform: 'web',
           bundle: shouldBundleFlag,
+          preserveJsPaths: esmAliasPaths,
         })
       : null,
 
@@ -743,6 +813,7 @@ async function buildJs(allFiles) {
           },
           {
             platform: 'web',
+            preserveJsPaths: esmAliasPaths,
           }
         )
       : null,
@@ -784,9 +855,11 @@ async function buildJs(allFiles) {
 async function esbuildWriteIfChanged(
   /** @type { import('esbuild').BuildOptions } */
   opts,
-  { platform, env, specifyCJS } = {
+  { platform, env, specifyCJS, keepJsOutput, preserveJsPaths } = {
     platform: '',
     specifyCJS: false,
+    keepJsOutput: false,
+    preserveJsPaths: [],
     env: '',
   }
 ) {
@@ -795,6 +868,10 @@ async function esbuildWriteIfChanged(
   }
 
   const isESM = opts.target === 'esm' || opts.target === 'esnext'
+  const preserveJsPathSet = new Set((preserveJsPaths || []).filter(Boolean))
+  const preserveJsPathAbsoluteSet = new Set(
+    [...preserveJsPathSet].map((preserveJsPath) => path.resolve(preserveJsPath))
+  )
 
   const buildSettings = (() => {
     // compat with jsx and hermes back a few versions generally:
@@ -852,7 +929,7 @@ async function esbuildWriteIfChanged(
       color: true,
       allowOverwrite: true,
       keepNames: false,
-      sourcemap: true,
+      sourcemap: !shouldSkipSourceMaps,
       sourcesContent: false,
       logLevel: 'error',
       ...(platform === 'native' && nativeEsbuildSettings),
@@ -962,23 +1039,35 @@ async function esbuildWriteIfChanged(
           }
         }
 
-        if (pkgRemoveSideEffects && isESM) {
-          const allowedSideEffects = pkg.sideEffects || []
+        if (isESM && pkg.sideEffects !== true && pkg.sideEffects !== undefined) {
+          const sideEffects = pkg.sideEffects
+          // sideEffects: false means nothing has side effects, strip all bare imports
+          // sideEffects: ["*.css", ...] means only matching files have side effects
+          const picomatch = require('picomatch')
+          const matchers = sideEffects === false
+            ? null // strip everything
+            : (Array.isArray(sideEffects) ? sideEffects : []).map((p) => picomatch(p))
 
           const result = []
           const lines = contents.split('\n')
           for (const line of lines) {
-            if (
-              !line.startsWith('import ') ||
-              allowedSideEffects.some((allowed) => line.includes(allowed))
-            ) {
+            // only process bare imports: import "...";
+            const match = line.match(/^import\s+["']([^"']+)["'];?$/)
+            if (!match) {
               result.push(line)
               continue
             }
-            result.push(line.replace(/import "[^"]+";/g, ''))
+            const specifier = match[1].replace(/^\.\//, '')
+            // sideEffects: false → strip all bare imports
+            if (matchers === null) {
+              result.push('')
+              continue
+            }
+            // sideEffects: [...] → keep if specifier matches any pattern
+            const hasSideEffect = matchers.some((m) => m(specifier))
+            result.push(hasSideEffect ? line : '')
           }
 
-          // match whitespace to preserve sourcemaps
           contents = result.join('\n')
         }
 
@@ -1018,7 +1107,7 @@ async function esbuildWriteIfChanged(
           : transform(contents, {
               filename: path,
               configFile: false,
-              sourceMap: true,
+              sourceMap: !shouldSkipSourceMaps,
               plugins: [
                 [
                   require.resolve('@tamagui/babel-plugin-fully-specified/commonjs'),
@@ -1029,11 +1118,28 @@ async function esbuildWriteIfChanged(
               ].filter(Boolean),
             })
 
-        cleanupNonCjsFiles.push(path)
+        const shouldPreserveJsAlias =
+          preserveJsPathSet.has(path) || preserveJsPathAbsoluteSet.has(path)
+
+        if (!shouldPreserveJsAlias) {
+          cleanupNonCjsFiles.push(path)
+          cleanupNonCjsFiles.push(path + '.map')
+        }
 
         await flush(path.replace(/\.js$/, '.cjs'), result.code)
+
+        if (shouldPreserveJsAlias) {
+          await flush(path, result.code)
+        }
       })
     )
+    if (cleanupNonCjsFiles.length) {
+      await Promise.all(cleanupNonCjsFiles.map(async (file) => FSE.remove(file)))
+    }
+    return
+  }
+
+  if (keepJsOutput) {
     return
   }
 
@@ -1060,7 +1166,7 @@ async function esbuildWriteIfChanged(
         : transform(contents, {
             filename: newOutPath,
             configFile: false,
-            sourceMap: true,
+            sourceMap: !shouldSkipSourceMaps,
             plugins: [
               [
                 isESM
@@ -1074,7 +1180,10 @@ async function esbuildWriteIfChanged(
             ].filter(Boolean),
           })
 
-      if (!path.includes('.native.')) {
+      const shouldPreserveJsAlias =
+        preserveJsPathSet.has(path) || preserveJsPathAbsoluteSet.has(path)
+
+      if (!path.includes('.native.') && !shouldPreserveJsAlias) {
         cleanupNonMjsFiles.push(path)
         cleanupNonMjsFiles.push(path + '.map')
       }
@@ -1083,25 +1192,39 @@ async function esbuildWriteIfChanged(
       await flush(
         newOutPath,
         result.code +
-          (result.map ? `\n//# sourceMappingURL=${basename(newOutPath)}.map\n` : '')
+          (result.map && !shouldSkipSourceMaps
+            ? `\n//# sourceMappingURL=${basename(newOutPath)}.map\n`
+            : '')
       )
-      if (result.map) {
+      if (result.map && !shouldSkipSourceMaps) {
         await flush(newOutPath + '.map', JSON.stringify(result.map))
+      } else {
+        await FSE.remove(newOutPath + '.map')
+      }
+
+      if (shouldPreserveJsAlias) {
+        await flush(
+          path,
+          result.code +
+            (result.map && !shouldSkipSourceMaps
+              ? `\n//# sourceMappingURL=${basename(path)}.map\n`
+              : '')
+        )
+        if (result.map && !shouldSkipSourceMaps) {
+          await flush(path + '.map', JSON.stringify(result.map))
+        } else {
+          await FSE.remove(path + '.map')
+        }
       }
     })
   )
 
-  // if we do mjs we should remove js after to avoid bloat
-  if (
-    process.env.TAMAGUI_BUILD_REMOVE_ESM_JS_FILES ||
-    process.env.TAMAGUI_BUILD_CLEANUP_JS_FILES
-  ) {
-    if (cleanupNonMjsFiles.length) {
-      await Promise.all(
-        [...cleanupNonMjsFiles, ...cleanupNonCjsFiles].map(async (file) => {
-          await FSE.remove(file)
-        })
-      )
-    }
+  // remove intermediary .js files once the final .mjs/.cjs outputs exist
+  if (cleanupNonMjsFiles.length || cleanupNonCjsFiles.length) {
+    await Promise.all(
+      [...cleanupNonMjsFiles, ...cleanupNonCjsFiles].map(async (file) => {
+        await FSE.remove(file)
+      })
+    )
   }
 }