tsrx-typegen 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alec Larson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -28,6 +28,16 @@ and removes stale files only when the manifest says it owns them. Same-name
 sources such as `Button.ts` and `Button.tsrx` need separate target configs or an
 explicit declaration override.
 
+Treat the output directory, including its ownership manifest, as generated
+build artifacts: ignore it in Git, formatting, and linting. Keep handwritten
+declarations and override sources outside that directory. Include the output
+directory in the package's `files` list so ignored declarations still ship in
+the tarball. Generate before local consumer typechecks, and regenerate in
+`prepack` before validating the package. Workspaces that resolve generated
+types directly also need generation during setup and refreshes during
+development; this repository's workflow is documented in
+[Develop against generated declarations](../../docs/toolchain-notes.md#develop-against-generated-declarations).
+
 `--project` selects the target whose project path matches. Use `--target` to
 select a named target directly. A target can look like this:
 
@@ -91,12 +101,21 @@ bare package imports are declared dependencies or peers. The command needs
 TypeScript consumer test for the module-resolution modes and public prop
 contracts your package supports.
 
+A target with `"emit": false` exists only to drive packed-package
+verification. Packages whose declarations are handwritten or produced by
+another tool declare one so `--pack-check` skips generation and freshness
+checks for it and only validates the packed package. Such targets cannot be
+selected for generation; a plain `--target` run against them fails. Every code
+export path still needs a `types` condition — pointing at a `.d.ts` file or,
+for source-published packages, the `.ts` source itself.
+
 Run the same gate from `prepack` so `pnpm pack` and publication share it:
 
 ```json
 {
   "scripts": {
-    "build": "vite build && tsrx-typegen --target octane",
+    "typegen": "tsrx-typegen --target octane",
+    "build": "vite build && pnpm typegen",
     "prepack": "pnpm build && tsrx-typegen --pack-check"
   }
 }

package/package.json

@@ -1,7 +1,18 @@
 {
   "name": "tsrx-typegen",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Generate consumer-ready TypeScript declarations for TSRX libraries",
+  "keywords": [
+    "tsrx",
+    "typegen",
+    "typescript",
+    "declarations",
+    "dts",
+    "codegen",
+    "build-tool"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/tsrx-typegen",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/octane-xplat/octane-xplat.git",

package/src/cli.mjs

@@ -36,6 +36,7 @@ Options:
   --target <name>   Target in tsrx-typegen.json (selects its project and output)
   --check           Compare generated declarations without writing files
   --pack-check      Check declarations, pack the package, and validate the tarball
+                    (targets with emit: false skip generation and only validate)
   -h, --help        Show this help`)
 }
 
@@ -99,7 +100,7 @@ function configuredTargetNames(projectRoot, selectedTarget) {
 		throw new Error(`${path}: unknown target ${selectedTarget}`)
 	}
 
-	return selectedTarget ? [selectedTarget] : Object.keys(targets)
+	return { names: selectedTarget ? [selectedTarget] : Object.keys(targets), targets }
 }
 
 function loadProjectModule(projectRoot, specifier) {
@@ -251,6 +252,10 @@ function configOptions(projectRoot, projectArgument, targetArgument) {
 	}
 
 	if (selected) {
+		if (selected.emit === false) {
+			throw new Error(`${path}: target ${selectedName} has emit: false — it configures --pack-check only`)
+		}
+
 		if (typeof selected.project !== 'string' || !selected.project) {
 			throw new Error(`${path}: target ${selectedName} must name a project`)
 		}
@@ -804,8 +809,12 @@ function run() {
 		return
 	}
 
-	const targets = configuredTargetNames(projectRoot, args.target)
-	for (const target of targets) {
+	const { names, targets } = configuredTargetNames(projectRoot, args.target)
+	for (const target of names) {
+		if (targets[target]?.emit === false) {
+			continue
+		}
+
 		if (!runTarget(projectRoot, { ...args, target, check: true })) {
 			process.exitCode = 1
 			return

package/src/pack-check.mjs

@@ -190,10 +190,15 @@ function localSourceModule(file, specifier) {
 	const candidates = [target]
 	if (extension === '.js' || extension === '.mjs' || extension === '.cjs') {
 		const stem = target.slice(0, -extension.length)
-		candidates.push(`${stem}.ts`, `${stem}.tsx`, `${stem}.tsrx`)
+		candidates.push(`${stem}.ts`, `${stem}.tsx`, `${stem}.tsrx`, `${stem}.d.ts`)
 	} else if (!['.ts', '.tsx', '.tsrx'].includes(extension)) {
-		candidates.push(`${target}.ts`, `${target}.tsx`, `${target}.tsrx`)
-		candidates.push(join(target, 'index.ts'), join(target, 'index.tsx'), join(target, 'index.tsrx'))
+		candidates.push(`${target}.ts`, `${target}.tsx`, `${target}.tsrx`, `${target}.d.ts`)
+		candidates.push(
+			join(target, 'index.ts'),
+			join(target, 'index.tsx'),
+			join(target, 'index.tsrx'),
+			join(target, 'index.d.ts'),
+		)
 	}
 
 	for (const candidate of candidates) {
@@ -285,7 +290,16 @@ function staticRuntimeExports(ts, file, seen = new Set()) {
 	return names
 }
 
-function compilerExports(ts, program, file) {
+function compilerExports(ts, program, file, cache = new Map(), pending = new Set()) {
+	const absolute = resolve(file)
+	if (cache.has(absolute)) {
+		return cache.get(absolute)
+	}
+
+	if (pending.has(absolute)) {
+		return { all: new Set(), values: new Set() }
+	}
+
 	const source = program.getSourceFile(file)
 	if (!source) {
 		return undefined
@@ -313,7 +327,57 @@ function compilerExports(ts, program, file) {
 		}
 	}
 
-	return { all, values }
+	// Type-only edges (`export type *`, `export type { X }`) re-list the
+	// target's symbols with their original flags — an ambient `declare const`
+	// still reads as a value even though no value binding crosses the edge.
+	// Subtract names whose only export edges are type-only.
+	const typeOnly = new Set()
+	for (const statement of source.statements) {
+		if (!ts.isExportDeclaration(statement) || !statement.isTypeOnly) {
+			continue
+		}
+
+		if (
+			!statement.exportClause &&
+			statement.moduleSpecifier &&
+			ts.isStringLiteralLike(statement.moduleSpecifier)
+		) {
+			pending.add(absolute)
+			const target = ts.resolveModuleName(
+				statement.moduleSpecifier.text,
+				file,
+				program.getCompilerOptions(),
+				ts.sys,
+			).resolvedModule?.resolvedFileName
+
+			const targetExports =
+				target && compilerExports(ts, program, target, cache, pending)
+
+			pending.delete(absolute)
+			for (const name of targetExports?.all ?? []) {
+				typeOnly.add(name)
+			}
+		} else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+			for (const element of statement.exportClause.elements) {
+				typeOnly.add(element.name.text)
+			}
+		} else if (statement.exportClause && ts.isNamespaceExport(statement.exportClause)) {
+			typeOnly.add(statement.exportClause.name.text)
+		}
+	}
+
+	if (typeOnly.size) {
+		const valueEdges = staticRuntimeExports(ts, file)
+		for (const name of values) {
+			if (typeOnly.has(name) && !valueEdges.has(name)) {
+				values.delete(name)
+			}
+		}
+	}
+
+	const result = { all, values }
+	cache.set(absolute, result)
+	return result
 }
 
 function declarationFiles(packageRoot, files) {