@twobirds/microcomponents 0.13.1 → 0.13.3

package/dist/cli/dev.d.ts

@@ -79,7 +79,8 @@ export declare function createDevServer(projectRoot: string, options: {
 }): Server;
 /**
  * CLI entry for `mc dev`: mirror companions, start the server, and run `tsc -w`
- * for the lifetime of the process.
+ * for the lifetime of the process. The watch runs with `--preserveWatchOutput`, so
+ * the screen is not cleared on each rebuild and the printed server URL stays visible.
  *
  * @param projectRoot Project root (defaults to the current directory).
  * @param minJs Path of `microcomponents.min.js` (defaults to this package's `dist/`).

package/dist/cli/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/cli/dev.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAsC,KAAK,MAAM,EAAuB,MAAM,WAAW,CAAC;AASjG;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO/F;AAkCD;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAW/F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtC,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AAEH,wBAAsB,MAAM,CAC3B,WAAW,GAAE,MAAsB,EACnC,KAAK,GAAE,MAAuE,EAC9E,IAAI,GAAE,MAAa,EACnB,IAAI,GAAE,MAAoB,GACxB,OAAO,CAAC,MAAM,CAAC,CAiCjB"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/cli/dev.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAsC,KAAK,MAAM,EAAuB,MAAM,WAAW,CAAC;AASjG;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO/F;AAkCD;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAW/F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtC,MAAM,CAKR;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,MAAM,CAC3B,WAAW,GAAE,MAAsB,EACnC,KAAK,GAAE,MAAuE,EAC9E,IAAI,GAAE,MAAa,EACnB,IAAI,GAAE,MAAoB,GACxB,OAAO,CAAC,MAAM,CAAC,CAoCjB"}

package/dist/cli/dispatch.d.ts

@@ -18,12 +18,38 @@ export type Runner = (script: string, options?: {
 /** Asks the user to confirm a namespace long enough to be worth a second look. */
 export type Confirmer = (namespace: string) => Promise<boolean>;
 /**
+Whether `mc <command>` runs the project's package.json script or the CLI's own
+implementation.
+
+A script that is a thin wrapper around the same command must not be delegated:
+`mc dev` would spawn `pnpm run dev`, which runs `mc dev`, which spawns
+`pnpm run dev`, forever. The scaffold writes exactly that shape (`"dev": "mc dev"`,
+`"preview": "mc preview"`), so this guard is what keeps `pnpm dev` in a scaffolded
+project from looping.
+
+@example
+```ts
+scriptTarget('mc dev', 'dev');                               // 'self'
+scriptTarget('mc dev --port 5173', 'dev');                   // 'self'
+scriptTarget('npx mc preview', 'preview');                   // 'self'
+scriptTarget('vite preview --outDir build', 'dev');          // 'delegate'
+scriptTarget('tsc -p tsconfig.json && mc bundle', 'bundle'); // 'delegate'
+scriptTarget(undefined, 'clean');                            // 'self'
+```
+@param body - The script body, or `undefined` when the project declares no such script.
+@param command - The `mc` command being run.
+@returns `'delegate'` to run the project script, `'self'` to run the CLI's implementation.
+*/
+export declare function scriptTarget(body: string | undefined, command: string): 'delegate' | 'self';
+/**
 Runs a package.json script through pnpm and resolves with its exit code.
 
 Thin wrappers like `clean` and `check` delegate here so the script — not the
 CLI — remains the single source of truth for what each command does. If the
 current project defines no such script, the CLI runs its own implementation
-against the current project, so the command works in any consumer project.
+against the current project, so the command works in any consumer project. A script
+that is a thin wrapper around the command itself is not delegated, because
+delegating makes the CLI run itself forever — see {@link scriptTarget}.
 
 @example
 ```ts

package/dist/cli/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/cli/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;EAYE;AAwEF,MAAM,MAAM,MAAM,GAAG,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KACtC,OAAO,CAAC,MAAM,CAAC,CAAC;AAErB,kFAAkF;AAClF,MAAM,MAAM,SAAS,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAyIhE;;;;;;;;;;;;EAYE;AACF,wBAAsB,SAAS,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;;;;;;;;;;;;;;;;;EAoBE;AACF,wBAAsB,IAAI,CACzB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,GAAE,MAAkB,EACvB,OAAO,GAAE,SAA4B,GACnC,OAAO,CAAC,MAAM,CAAC,CA4IjB"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/cli/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;EAYE;AAwEF,MAAM,MAAM,MAAM,GAAG,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KACtC,OAAO,CAAC,MAAM,CAAC,CAAC;AAErB,kFAAkF;AAClF,MAAM,MAAM,SAAS,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAgFhE;;;;;;;;;;;;;;;;;;;;;;EAsBE;AACF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAQ3F;AAgED;;;;;;;;;;;;;;EAcE;AACF,wBAAsB,SAAS,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;;;;;;;;;;;;;;;;;EAoBE;AACF,wBAAsB,IAAI,CACzB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,GAAE,MAAkB,EACvB,OAAO,GAAE,SAA4B,GACnC,OAAO,CAAC,MAAM,CAAC,CA4IjB"}

package/dist/cli/index.js

@@ -267,7 +267,7 @@ function packageJson(namespace) {
 			typecheck: "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json",
 			test: "vitest run"
 		},
-		dependencies: { "@twobirds/microcomponents": "^0.13.1" },
+		dependencies: { "@twobirds/microcomponents": "^0.13.3" },
 		devDependencies: {
 			typescript: "^6.0.3",
 			vitest: "^4.1.10",
@@ -1462,7 +1462,8 @@ function createDevServer(projectRoot, options) {
 }
 /**
 * CLI entry for `mc dev`: mirror companions, start the server, and run `tsc -w`
-* for the lifetime of the process.
+* for the lifetime of the process. The watch runs with `--preserveWatchOutput`, so
+* the screen is not cleared on each rebuild and the printed server URL stays visible.
 *
 * @param projectRoot Project root (defaults to the current directory).
 * @param minJs Path of `microcomponents.min.js` (defaults to this package's `dist/`).
@@ -1471,7 +1472,6 @@ function createDevServer(projectRoot, options) {
 *   not reachable off the machine. Pass an interface address to serve the LAN.
 * @returns The process exit code (the server keeps running until killed).
 */
-/* v8 ignore start — the long-running server + tsc watch is exercised by hand, not in the suite */
 async function runDev(projectRoot = process.cwd(), minJs = path.join(import.meta.dirname, "..", "microcomponents.min.js"), port = 5173, host = "127.0.0.1") {
 	const sourceRoot = path.join(projectRoot, "src");
 	const buildRoot = path.join(projectRoot, "build");
@@ -1479,6 +1479,7 @@ async function runDev(projectRoot = process.cwd(), minJs = path.join(import.meta
 	const tsc = spawn("npx", [
 		"tsc",
 		"-w",
+		"--preserveWatchOutput",
 		"-p",
 		"tsconfig.json"
 	], {
@@ -1506,7 +1507,6 @@ async function runDev(projectRoot = process.cwd(), minJs = path.join(import.meta
 		});
 	});
 }
-/* v8 ignore end */
 //#endregion
 //#region src/cli/preview.ts
 /**
@@ -1721,23 +1721,56 @@ function spawnProcess(command, args, cwd) {
 	});
 }
 /**
-Whether the package.json in the current directory declares `script` in its
-"scripts". Consumers get this check so `mc clean`/`mc check` can fall back to
-the CLI's own implementation when the project defines no such script.
+The body of a package.json script in the current directory, or `undefined` when the
+project declares no such script. Consumers get this check so `mc clean`/`mc check`
+can fall back to the CLI's own implementation when the project defines no such script.
 
 @example
 ```ts
-const ok = await hasScript('clean');
+await scriptBody('clean');  // 'rm -rf dist'
+await scriptBody('nope');   // undefined
 ```
 @param script - Script name to look up.
 */
-async function hasScript(script) {
+async function scriptBody(script) {
 	try {
-		return typeof JSON.parse(await readFile(path.join(process.cwd(), "package.json"), "utf8"))?.scripts?.[script] === "string";
+		const body = JSON.parse(await readFile(path.join(process.cwd(), "package.json"), "utf8"))?.scripts?.[script];
+		return typeof body === "string" ? body : void 0;
 	} catch {
-		return false;
+		return;
 	}
 }
+/** The CLI's own bin names, so a script that wraps this command is recognized. */
+var SELF_BINS = /* @__PURE__ */ new Set(["mc", "microcomponents"]);
+/**
+Whether `mc <command>` runs the project's package.json script or the CLI's own
+implementation.
+
+A script that is a thin wrapper around the same command must not be delegated:
+`mc dev` would spawn `pnpm run dev`, which runs `mc dev`, which spawns
+`pnpm run dev`, forever. The scaffold writes exactly that shape (`"dev": "mc dev"`,
+`"preview": "mc preview"`), so this guard is what keeps `pnpm dev` in a scaffolded
+project from looping.
+
+@example
+```ts
+scriptTarget('mc dev', 'dev');                               // 'self'
+scriptTarget('mc dev --port 5173', 'dev');                   // 'self'
+scriptTarget('npx mc preview', 'preview');                   // 'self'
+scriptTarget('vite preview --outDir build', 'dev');          // 'delegate'
+scriptTarget('tsc -p tsconfig.json && mc bundle', 'bundle'); // 'delegate'
+scriptTarget(undefined, 'clean');                            // 'self'
+```
+@param body - The script body, or `undefined` when the project declares no such script.
+@param command - The `mc` command being run.
+@returns `'delegate'` to run the project script, `'self'` to run the CLI's implementation.
+*/
+function scriptTarget(body, command) {
+	if (!body) return "self";
+	const tokens = body.trim().split(/\s+/);
+	while (tokens[0] === "npx" || tokens[0] === "pnpm" && tokens[1] === "exec") tokens.splice(0, tokens[0] === "npx" ? 1 : 2);
+	return SELF_BINS.has(tokens[0]) && tokens[1] === command ? "self" : "delegate";
+}
 /** Build artifacts to remove, relative to the project root. */
 var CLEAN_DIRS = [
 	"dist",
@@ -1811,7 +1844,9 @@ Runs a package.json script through pnpm and resolves with its exit code.
 Thin wrappers like `clean` and `check` delegate here so the script — not the
 CLI — remains the single source of truth for what each command does. If the
 current project defines no such script, the CLI runs its own implementation
-against the current project, so the command works in any consumer project.
+against the current project, so the command works in any consumer project. A script
+that is a thin wrapper around the command itself is not delegated, because
+delegating makes the CLI run itself forever — see {@link scriptTarget}.
 
 @example
 ```ts
@@ -1819,7 +1854,7 @@ const code = await runScript('check');
 ```
 */
 async function runScript(script, options) {
-	if (await hasScript(script)) return spawnProcess("pnpm", ["run", script]);
+	if (scriptTarget(await scriptBody(script), script) === "delegate") return spawnProcess("pnpm", ["run", script]);
 	if (script === "clean") return cleanSelf();
 	if (script === "check") return checkSelf();
 	if (script === "dev") return runDev(process.cwd(), void 0, options?.port ?? 5173, options?.host ?? "127.0.0.1");

package/dist/docs/cli.d.ts

@@ -57,7 +57,9 @@ on demand through `autoload()` — nothing is bundled, and a new component is pi
 without restarting. The server rewrites the `@twobirds/microcomponents` specifier in the
 JS it serves to the `/microcomponents.min.js` it answers, so the page carries no import
 map, and it mirrors the files `tsc` does not compile — companion assets and plain `.js`
-components — into `build/` next to the compiled component.
+components — into `build/` next to the compiled component. The watch runs with
+`--preserveWatchOutput`, so `tsc` does not clear the screen on each rebuild and the
+server URL the process prints stays visible.
 
 ```sh
 mc dev                 # dev server on port 5173, bound to 127.0.0.1
@@ -110,7 +112,7 @@ mc check
 Reports the version of the installed library, not the version of the project it runs in.
 
 ```sh
-mc --version      # 0.13.1
+mc --version      # 0.13.3
 ```
 
 ## mc --help

package/dist/docs/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/docs/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0HE"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/docs/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4HE"}

package/dist/mcp/api.json

@@ -1,5 +1,5 @@
 {
-  "libraryVersion": "0.13.1",
+  "libraryVersion": "0.13.3",
   "exportedCount": 59,
   "entries": {
     "MC": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twobirds/microcomponents",
-	"version": "0.13.1",
+	"version": "0.13.3",
 	"description": "Micro Components",
 	"keywords": [
 		"PWA",