@benjavicente/router-utils 1.161.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+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/dist/cjs/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/cjs/ast.cjs

@@ -0,0 +1,104 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let _babel_parser = require("@babel/parser");
+let _babel_generator = require("@babel/generator");
+_babel_generator = require_runtime.__toESM(_babel_generator);
+let _babel_types = require("@babel/types");
+_babel_types = require_runtime.__toESM(_babel_types);
+let babel_dead_code_elimination = require("babel-dead-code-elimination");
+//#region src/ast.ts
+function parseAst({ code, ...opts }) {
+	return (0, _babel_parser.parse)(code, {
+		plugins: [
+			"jsx",
+			"typescript",
+			"explicitResourceManagement",
+			"decorators"
+		],
+		sourceType: "module",
+		...opts
+	});
+}
+var generate = _babel_generator.default;
+if ("default" in generate) generate = generate.default;
+function generateFromAst(ast, opts) {
+	return generate(ast, opts ? {
+		importAttributesKeyword: "with",
+		sourceMaps: true,
+		...opts
+	} : void 0);
+}
+/**
+* Strips TypeScript type-only exports and imports from an AST.
+*
+* This is necessary because babel-dead-code-elimination doesn't handle
+* TypeScript type exports/imports. When a type export references an import
+* that pulls in server-only code, the dead code elimination won't remove
+* that import because it sees the type as still referencing it.
+*
+* This function removes:
+* - `export type Foo = ...`
+* - `export interface Foo { ... }`
+* - `export type { Foo } from './module'`
+* - `export type * from './module'`
+* - Type specifiers in mixed exports: `export { value, type Foo }` -> `export { value }`
+* - `import type { Foo } from './module'`
+* - Type specifiers in mixed imports: `import { value, type Foo } from './module'` -> `import { value }`
+*
+* Note: Non-exported type/interface declarations are preserved as they may be
+* used as type annotations within the code.
+*
+* @param ast - The Babel AST (or ParseResult) to mutate
+*/
+function stripTypeExports(ast) {
+	ast.program.body = ast.program.body.filter((node) => {
+		if (_babel_types.isExportNamedDeclaration(node)) {
+			if (node.exportKind === "type") return false;
+			if (node.specifiers.length > 0) {
+				node.specifiers = node.specifiers.filter((specifier) => {
+					if (_babel_types.isExportSpecifier(specifier)) return specifier.exportKind !== "type";
+					return true;
+				});
+				if (node.specifiers.length === 0 && !node.declaration) return false;
+			}
+		}
+		if (_babel_types.isExportAllDeclaration(node)) {
+			if (node.exportKind === "type") return false;
+		}
+		if (_babel_types.isImportDeclaration(node)) {
+			if (node.importKind === "type") return false;
+			if (node.specifiers.length > 0) {
+				node.specifiers = node.specifiers.filter((specifier) => {
+					if (_babel_types.isImportSpecifier(specifier)) return specifier.importKind !== "type";
+					return true;
+				});
+				if (node.specifiers.length === 0) return false;
+			}
+		}
+		return true;
+	});
+}
+/**
+* Performs dead code elimination on the AST, with TypeScript type stripping.
+*
+* This is a wrapper around babel-dead-code-elimination that first strips
+* TypeScript type-only exports and imports. This is necessary because
+* babel-dead-code-elimination doesn't handle type exports, which can cause
+* imports to be retained when they're only referenced by type exports.
+*
+* @param ast - The Babel AST to mutate
+* @param candidates - Optional set of identifier paths to consider for removal.
+*                     If provided, only these identifiers will be candidates for removal.
+*                     This should be the result of `findReferencedIdentifiers(ast)` called
+*                     before any AST transformations.
+*/
+function deadCodeElimination(ast, candidates) {
+	stripTypeExports(ast);
+	(0, babel_dead_code_elimination.deadCodeElimination)(ast, candidates);
+}
+//#endregion
+exports.deadCodeElimination = deadCodeElimination;
+exports.generateFromAst = generateFromAst;
+exports.parseAst = parseAst;
+exports.stripTypeExports = stripTypeExports;
+
+//# sourceMappingURL=ast.cjs.map

package/dist/cjs/ast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.cjs","names":[],"sources":["../../src/ast.ts"],"sourcesContent":["import { parse } from '@babel/parser'\nimport _generate from '@babel/generator'\nimport * as t from '@babel/types'\nimport {\n  deadCodeElimination as _deadCodeElimination,\n  findReferencedIdentifiers,\n} from 'babel-dead-code-elimination'\nimport type { GeneratorOptions, GeneratorResult } from '@babel/generator'\nimport type { ParseResult, ParserOptions } from '@babel/parser'\nimport type * as _babel_types from '@babel/types'\n\nexport type ParseAstOptions = ParserOptions & {\n  code: string\n}\n\nexport type ParseAstResult = ParseResult<_babel_types.File>\nexport function parseAst({ code, ...opts }: ParseAstOptions): ParseAstResult {\n  return parse(code, {\n    plugins: [\n      'jsx',\n      'typescript',\n      'explicitResourceManagement',\n      'decorators', // required for Angular and other decorator-based code\n    ],\n    sourceType: 'module',\n    ...opts,\n  })\n}\n\nlet generate = _generate\n\nif ('default' in generate) {\n  generate = generate.default as typeof generate\n}\ntype GenerateFromAstOptions = GeneratorOptions &\n  Required<Pick<GeneratorOptions, 'sourceFileName' | 'filename'>>\nexport function generateFromAst(\n  ast: _babel_types.Node,\n  opts?: GenerateFromAstOptions,\n): GeneratorResult {\n  return generate(\n    ast,\n    opts\n      ? { importAttributesKeyword: 'with', sourceMaps: true, ...opts }\n      : undefined,\n  )\n}\nexport type { GeneratorResult } from '@babel/generator'\n\n/**\n * Strips TypeScript type-only exports and imports from an AST.\n *\n * This is necessary because babel-dead-code-elimination doesn't handle\n * TypeScript type exports/imports. When a type export references an import\n * that pulls in server-only code, the dead code elimination won't remove\n * that import because it sees the type as still referencing it.\n *\n * This function removes:\n * - `export type Foo = ...`\n * - `export interface Foo { ... }`\n * - `export type { Foo } from './module'`\n * - `export type * from './module'`\n * - Type specifiers in mixed exports: `export { value, type Foo }` -> `export { value }`\n * - `import type { Foo } from './module'`\n * - Type specifiers in mixed imports: `import { value, type Foo } from './module'` -> `import { value }`\n *\n * Note: Non-exported type/interface declarations are preserved as they may be\n * used as type annotations within the code.\n *\n * @param ast - The Babel AST (or ParseResult) to mutate\n */\nexport function stripTypeExports(ast: ParseResult<_babel_types.File>): void {\n  // Filter the program body to remove type-only nodes\n  ast.program.body = ast.program.body.filter((node) => {\n    // Handle export declarations\n    if (t.isExportNamedDeclaration(node)) {\n      // Remove entire export if it's a type-only export\n      // e.g., `export type Foo = string`, `export interface Bar {}`, `export type { X } from './y'`\n      if (node.exportKind === 'type') {\n        return false\n      }\n\n      // For value exports with mixed specifiers, filter out type-only specifiers\n      // e.g., `export { value, type TypeOnly }` -> `export { value }`\n      if (node.specifiers.length > 0) {\n        node.specifiers = node.specifiers.filter((specifier) => {\n          if (t.isExportSpecifier(specifier)) {\n            return specifier.exportKind !== 'type'\n          }\n          return true\n        })\n\n        // If all specifiers were removed, remove the entire export declaration\n        // (unless it has a declaration like `export const x = 1`)\n        if (node.specifiers.length === 0 && !node.declaration) {\n          return false\n        }\n      }\n    }\n\n    // Handle type-only export-all declarations\n    // e.g., `export type * from './module'`\n    if (t.isExportAllDeclaration(node)) {\n      if (node.exportKind === 'type') {\n        return false\n      }\n    }\n\n    // Handle import declarations\n    if (t.isImportDeclaration(node)) {\n      // Remove entire import if it's a type-only import\n      // e.g., `import type { Foo } from './module'`\n      if (node.importKind === 'type') {\n        return false\n      }\n\n      // For value imports with mixed specifiers, filter out type-only specifiers\n      // e.g., `import { value, type TypeOnly } from './module'` -> `import { value }`\n      if (node.specifiers.length > 0) {\n        node.specifiers = node.specifiers.filter((specifier) => {\n          if (t.isImportSpecifier(specifier)) {\n            return specifier.importKind !== 'type'\n          }\n          return true\n        })\n\n        // If all specifiers were removed, remove the entire import declaration\n        if (node.specifiers.length === 0) {\n          return false\n        }\n      }\n    }\n\n    return true\n  })\n}\n\n// Re-export findReferencedIdentifiers from babel-dead-code-elimination\nexport { findReferencedIdentifiers }\n\n/**\n * Performs dead code elimination on the AST, with TypeScript type stripping.\n *\n * This is a wrapper around babel-dead-code-elimination that first strips\n * TypeScript type-only exports and imports. This is necessary because\n * babel-dead-code-elimination doesn't handle type exports, which can cause\n * imports to be retained when they're only referenced by type exports.\n *\n * @param ast - The Babel AST to mutate\n * @param candidates - Optional set of identifier paths to consider for removal.\n *                     If provided, only these identifiers will be candidates for removal.\n *                     This should be the result of `findReferencedIdentifiers(ast)` called\n *                     before any AST transformations.\n */\nexport function deadCodeElimination(\n  ast: ParseResult<_babel_types.File>,\n  candidates?: ReturnType<typeof findReferencedIdentifiers>,\n): void {\n  // First strip TypeScript type-only exports and imports\n  stripTypeExports(ast)\n\n  // Then run the original dead code elimination\n  _deadCodeElimination(ast, candidates)\n}\n"],"mappings":";;;;;;;;AAgBA,SAAgB,SAAS,EAAE,MAAM,GAAG,QAAyC;AAC3E,SAAA,GAAA,cAAA,OAAa,MAAM;EACjB,SAAS;GACP;GACA;GACA;GACA;GACD;EACD,YAAY;EACZ,GAAG;EACJ,CAAC;;AAGJ,IAAI,WAAW,iBAAA;AAEf,IAAI,aAAa,SACf,YAAW,SAAS;AAItB,SAAgB,gBACd,KACA,MACiB;AACjB,QAAO,SACL,KACA,OACI;EAAE,yBAAyB;EAAQ,YAAY;EAAM,GAAG;EAAM,GAC9D,KAAA,EACL;;;;;;;;;;;;;;;;;;;;;;;;AA0BH,SAAgB,iBAAiB,KAA2C;AAE1E,KAAI,QAAQ,OAAO,IAAI,QAAQ,KAAK,QAAQ,SAAS;AAEnD,MAAI,aAAE,yBAAyB,KAAK,EAAE;AAGpC,OAAI,KAAK,eAAe,OACtB,QAAO;AAKT,OAAI,KAAK,WAAW,SAAS,GAAG;AAC9B,SAAK,aAAa,KAAK,WAAW,QAAQ,cAAc;AACtD,SAAI,aAAE,kBAAkB,UAAU,CAChC,QAAO,UAAU,eAAe;AAElC,YAAO;MACP;AAIF,QAAI,KAAK,WAAW,WAAW,KAAK,CAAC,KAAK,YACxC,QAAO;;;AAOb,MAAI,aAAE,uBAAuB,KAAK;OAC5B,KAAK,eAAe,OACtB,QAAO;;AAKX,MAAI,aAAE,oBAAoB,KAAK,EAAE;AAG/B,OAAI,KAAK,eAAe,OACtB,QAAO;AAKT,OAAI,KAAK,WAAW,SAAS,GAAG;AAC9B,SAAK,aAAa,KAAK,WAAW,QAAQ,cAAc;AACtD,SAAI,aAAE,kBAAkB,UAAU,CAChC,QAAO,UAAU,eAAe;AAElC,YAAO;MACP;AAGF,QAAI,KAAK,WAAW,WAAW,EAC7B,QAAO;;;AAKb,SAAO;GACP;;;;;;;;;;;;;;;;AAoBJ,SAAgB,oBACd,KACA,YACM;AAEN,kBAAiB,IAAI;AAGrB,EAAA,GAAA,4BAAA,qBAAqB,KAAK,WAAW"}

package/dist/cjs/ast.d.cts

@@ -0,0 +1,51 @@
+import { findReferencedIdentifiers } from 'babel-dead-code-elimination';
+import { GeneratorOptions, GeneratorResult } from '@babel/generator';
+import { ParseResult, ParserOptions } from '@babel/parser';
+import type * as _babel_types from '@babel/types';
+export type ParseAstOptions = ParserOptions & {
+    code: string;
+};
+export type ParseAstResult = ParseResult<_babel_types.File>;
+export declare function parseAst({ code, ...opts }: ParseAstOptions): ParseAstResult;
+type GenerateFromAstOptions = GeneratorOptions & Required<Pick<GeneratorOptions, 'sourceFileName' | 'filename'>>;
+export declare function generateFromAst(ast: _babel_types.Node, opts?: GenerateFromAstOptions): GeneratorResult;
+export type { GeneratorResult } from '@babel/generator';
+/**
+ * Strips TypeScript type-only exports and imports from an AST.
+ *
+ * This is necessary because babel-dead-code-elimination doesn't handle
+ * TypeScript type exports/imports. When a type export references an import
+ * that pulls in server-only code, the dead code elimination won't remove
+ * that import because it sees the type as still referencing it.
+ *
+ * This function removes:
+ * - `export type Foo = ...`
+ * - `export interface Foo { ... }`
+ * - `export type { Foo } from './module.cjs'`
+ * - `export type * from './module.cjs'`
+ * - Type specifiers in mixed exports: `export { value, type Foo }` -> `export { value }`
+ * - `import type { Foo } from './module.cjs'`
+ * - Type specifiers in mixed imports: `import { value, type Foo } from './module.cjs'` -> `import { value }`
+ *
+ * Note: Non-exported type/interface declarations are preserved as they may be
+ * used as type annotations within the code.
+ *
+ * @param ast - The Babel AST (or ParseResult) to mutate
+ */
+export declare function stripTypeExports(ast: ParseResult<_babel_types.File>): void;
+export { findReferencedIdentifiers };
+/**
+ * Performs dead code elimination on the AST, with TypeScript type stripping.
+ *
+ * This is a wrapper around babel-dead-code-elimination that first strips
+ * TypeScript type-only exports and imports. This is necessary because
+ * babel-dead-code-elimination doesn't handle type exports, which can cause
+ * imports to be retained when they're only referenced by type exports.
+ *
+ * @param ast - The Babel AST to mutate
+ * @param candidates - Optional set of identifier paths to consider for removal.
+ *                     If provided, only these identifiers will be candidates for removal.
+ *                     This should be the result of `findReferencedIdentifiers(ast)` called
+ *                     before any AST transformations.
+ */
+export declare function deadCodeElimination(ast: ParseResult<_babel_types.File>, candidates?: ReturnType<typeof findReferencedIdentifiers>): void;

package/dist/cjs/copy-files-plugin.cjs

@@ -0,0 +1,24 @@
+require("./_virtual/_rolldown/runtime.cjs");
+let node_fs_promises = require("node:fs/promises");
+let pathe = require("pathe");
+let tinyglobby = require("tinyglobby");
+//#region src/copy-files-plugin.ts
+function copyFilesPlugin({ fromDir, toDir, pattern = "**" }) {
+	return {
+		name: "copy-files",
+		async writeBundle() {
+			const entries = await (0, tinyglobby.glob)(pattern, { cwd: fromDir });
+			if (entries.length === 0) throw new Error(`No files found matching pattern "${pattern}" in directory "${fromDir}"`);
+			for (const entry of entries) {
+				const srcPath = (0, pathe.join)(fromDir, entry);
+				const destPath = (0, pathe.join)(toDir, entry);
+				await (0, node_fs_promises.mkdir)((0, pathe.dirname)(destPath), { recursive: true });
+				await (0, node_fs_promises.copyFile)(srcPath, destPath);
+			}
+		}
+	};
+}
+//#endregion
+exports.copyFilesPlugin = copyFilesPlugin;
+
+//# sourceMappingURL=copy-files-plugin.cjs.map

package/dist/cjs/copy-files-plugin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-files-plugin.cjs","names":[],"sources":["../../src/copy-files-plugin.ts"],"sourcesContent":["import { copyFile, mkdir } from 'node:fs/promises'\nimport { dirname, join } from 'pathe'\nimport { glob } from 'tinyglobby'\nimport type { Plugin } from 'vite'\n\nexport function copyFilesPlugin({\n  fromDir,\n  toDir,\n  pattern = '**',\n}: {\n  pattern?: string | Array<string>\n  fromDir: string\n  toDir: string\n}): Plugin {\n  return {\n    name: 'copy-files',\n    async writeBundle() {\n      const entries = await glob(pattern, { cwd: fromDir })\n      if (entries.length === 0) {\n        throw new Error(\n          `No files found matching pattern \"${pattern}\" in directory \"${fromDir}\"`,\n        )\n      }\n\n      for (const entry of entries) {\n        const srcPath = join(fromDir, entry)\n        const destPath = join(toDir, entry)\n        // Ensure the destination directory exists\n        await mkdir(dirname(destPath), { recursive: true })\n        await copyFile(srcPath, destPath)\n      }\n    },\n  }\n}\n"],"mappings":";;;;;AAKA,SAAgB,gBAAgB,EAC9B,SACA,OACA,UAAU,QAKD;AACT,QAAO;EACL,MAAM;EACN,MAAM,cAAc;GAClB,MAAM,UAAU,OAAA,GAAA,WAAA,MAAW,SAAS,EAAE,KAAK,SAAS,CAAC;AACrD,OAAI,QAAQ,WAAW,EACrB,OAAM,IAAI,MACR,oCAAoC,QAAQ,kBAAkB,QAAQ,GACvE;AAGH,QAAK,MAAM,SAAS,SAAS;IAC3B,MAAM,WAAA,GAAA,MAAA,MAAe,SAAS,MAAM;IACpC,MAAM,YAAA,GAAA,MAAA,MAAgB,OAAO,MAAM;AAEnC,WAAA,GAAA,iBAAA,QAAA,GAAA,MAAA,SAAoB,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC;AACnD,WAAA,GAAA,iBAAA,UAAe,SAAS,SAAS;;;EAGtC"}

package/dist/cjs/copy-files-plugin.d.cts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+export declare function copyFilesPlugin({ fromDir, toDir, pattern, }: {
+    pattern?: string | Array<string>;
+    fromDir: string;
+    toDir: string;
+}): Plugin;

package/dist/cjs/index.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./_virtual/_rolldown/runtime.cjs");
+const require_ast = require("./ast.cjs");
+const require_logger = require("./logger.cjs");
+const require_copy_files_plugin = require("./copy-files-plugin.cjs");
+let babel_dead_code_elimination = require("babel-dead-code-elimination");
+exports.copyFilesPlugin = require_copy_files_plugin.copyFilesPlugin;
+exports.deadCodeElimination = require_ast.deadCodeElimination;
+exports.findReferencedIdentifiers = babel_dead_code_elimination.findReferencedIdentifiers;
+exports.generateFromAst = require_ast.generateFromAst;
+exports.logDiff = require_logger.logDiff;
+exports.parseAst = require_ast.parseAst;
+exports.stripTypeExports = require_ast.stripTypeExports;

package/dist/cjs/index.d.cts

@@ -0,0 +1,4 @@
+export { parseAst, generateFromAst, deadCodeElimination, findReferencedIdentifiers, stripTypeExports, } from './ast.cjs';
+export type { ParseAstOptions, ParseAstResult, GeneratorResult } from './ast.cjs';
+export { logDiff } from './logger.cjs';
+export { copyFilesPlugin } from './copy-files-plugin.cjs';

package/dist/cjs/logger.cjs

@@ -0,0 +1,50 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let ansis = require("ansis");
+ansis = require_runtime.__toESM(ansis);
+let diff = require("diff");
+//#region src/logger.ts
+function logDiff(oldStr, newStr) {
+	const differences = (0, diff.diffWords)(oldStr, newStr);
+	let output = "";
+	let unchangedLines = "";
+	function processUnchangedLines(lines) {
+		const lineArray = lines.split("\n");
+		if (lineArray.length > 4) return [
+			ansis.default.dim(lineArray[0]),
+			ansis.default.dim(lineArray[1]),
+			"",
+			ansis.default.dim.bold(`... (${lineArray.length - 4} lines) ...`),
+			"",
+			ansis.default.dim(lineArray[lineArray.length - 2]),
+			ansis.default.dim(lineArray[lineArray.length - 1])
+		].join("\n");
+		return ansis.default.dim(lines);
+	}
+	differences.forEach((part, index) => {
+		const nextPart = differences[index + 1];
+		if (part.added) {
+			if (unchangedLines) {
+				output += processUnchangedLines(unchangedLines);
+				unchangedLines = "";
+			}
+			output += ansis.default.green.bold(part.value);
+			if (nextPart?.removed) output += " ";
+		} else if (part.removed) {
+			if (unchangedLines) {
+				output += processUnchangedLines(unchangedLines);
+				unchangedLines = "";
+			}
+			output += ansis.default.red.bold(part.value);
+			if (nextPart?.added) output += " ";
+		} else unchangedLines += part.value;
+	});
+	if (unchangedLines) output += processUnchangedLines(unchangedLines);
+	if (output) {
+		console.log("\nDiff:");
+		console.log(output + "\n\n");
+	} else console.log("No changes");
+}
+//#endregion
+exports.logDiff = logDiff;
+
+//# sourceMappingURL=logger.cjs.map

package/dist/cjs/logger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.cjs","names":[],"sources":["../../src/logger.ts"],"sourcesContent":["import ansis from 'ansis'\nimport { diffWords } from 'diff'\n\nexport function logDiff(oldStr: string, newStr: string) {\n  const differences = diffWords(oldStr, newStr)\n\n  let output = ''\n  let unchangedLines = ''\n\n  function processUnchangedLines(lines: string): string {\n    const lineArray = lines.split('\\n')\n    if (lineArray.length > 4) {\n      return [\n        ansis.dim(lineArray[0]),\n        ansis.dim(lineArray[1]),\n        '',\n        ansis.dim.bold(`... (${lineArray.length - 4} lines) ...`),\n        '',\n        ansis.dim(lineArray[lineArray.length - 2]),\n        ansis.dim(lineArray[lineArray.length - 1]),\n      ].join('\\n')\n    }\n    return ansis.dim(lines)\n  }\n\n  differences.forEach((part, index) => {\n    const nextPart = differences[index + 1]\n\n    if (part.added) {\n      if (unchangedLines) {\n        output += processUnchangedLines(unchangedLines)\n        unchangedLines = ''\n      }\n      output += ansis.green.bold(part.value)\n      if (nextPart?.removed) output += ' '\n    } else if (part.removed) {\n      if (unchangedLines) {\n        output += processUnchangedLines(unchangedLines)\n        unchangedLines = ''\n      }\n      output += ansis.red.bold(part.value)\n      if (nextPart?.added) output += ' '\n    } else {\n      unchangedLines += part.value\n    }\n  })\n\n  // Process any remaining unchanged lines at the end\n  if (unchangedLines) {\n    output += processUnchangedLines(unchangedLines)\n  }\n\n  if (output) {\n    console.log('\\nDiff:')\n    console.log(output + '\\n\\n')\n  } else {\n    console.log('No changes')\n  }\n}\n"],"mappings":";;;;;AAGA,SAAgB,QAAQ,QAAgB,QAAgB;CACtD,MAAM,eAAA,GAAA,KAAA,WAAwB,QAAQ,OAAO;CAE7C,IAAI,SAAS;CACb,IAAI,iBAAiB;CAErB,SAAS,sBAAsB,OAAuB;EACpD,MAAM,YAAY,MAAM,MAAM,KAAK;AACnC,MAAI,UAAU,SAAS,EACrB,QAAO;GACL,MAAA,QAAM,IAAI,UAAU,GAAG;GACvB,MAAA,QAAM,IAAI,UAAU,GAAG;GACvB;GACA,MAAA,QAAM,IAAI,KAAK,QAAQ,UAAU,SAAS,EAAE,aAAa;GACzD;GACA,MAAA,QAAM,IAAI,UAAU,UAAU,SAAS,GAAG;GAC1C,MAAA,QAAM,IAAI,UAAU,UAAU,SAAS,GAAG;GAC3C,CAAC,KAAK,KAAK;AAEd,SAAO,MAAA,QAAM,IAAI,MAAM;;AAGzB,aAAY,SAAS,MAAM,UAAU;EACnC,MAAM,WAAW,YAAY,QAAQ;AAErC,MAAI,KAAK,OAAO;AACd,OAAI,gBAAgB;AAClB,cAAU,sBAAsB,eAAe;AAC/C,qBAAiB;;AAEnB,aAAU,MAAA,QAAM,MAAM,KAAK,KAAK,MAAM;AACtC,OAAI,UAAU,QAAS,WAAU;aACxB,KAAK,SAAS;AACvB,OAAI,gBAAgB;AAClB,cAAU,sBAAsB,eAAe;AAC/C,qBAAiB;;AAEnB,aAAU,MAAA,QAAM,IAAI,KAAK,KAAK,MAAM;AACpC,OAAI,UAAU,MAAO,WAAU;QAE/B,mBAAkB,KAAK;GAEzB;AAGF,KAAI,eACF,WAAU,sBAAsB,eAAe;AAGjD,KAAI,QAAQ;AACV,UAAQ,IAAI,UAAU;AACtB,UAAQ,IAAI,SAAS,OAAO;OAE5B,SAAQ,IAAI,aAAa"}

package/dist/cjs/logger.d.cts

@@ -0,0 +1 @@
+export declare function logDiff(oldStr: string, newStr: string): void;

package/dist/esm/ast.d.ts

@@ -0,0 +1,51 @@
+import { findReferencedIdentifiers } from 'babel-dead-code-elimination';
+import { GeneratorOptions, GeneratorResult } from '@babel/generator';
+import { ParseResult, ParserOptions } from '@babel/parser';
+import type * as _babel_types from '@babel/types';
+export type ParseAstOptions = ParserOptions & {
+    code: string;
+};
+export type ParseAstResult = ParseResult<_babel_types.File>;
+export declare function parseAst({ code, ...opts }: ParseAstOptions): ParseAstResult;
+type GenerateFromAstOptions = GeneratorOptions & Required<Pick<GeneratorOptions, 'sourceFileName' | 'filename'>>;
+export declare function generateFromAst(ast: _babel_types.Node, opts?: GenerateFromAstOptions): GeneratorResult;
+export type { GeneratorResult } from '@babel/generator';
+/**
+ * Strips TypeScript type-only exports and imports from an AST.
+ *
+ * This is necessary because babel-dead-code-elimination doesn't handle
+ * TypeScript type exports/imports. When a type export references an import
+ * that pulls in server-only code, the dead code elimination won't remove
+ * that import because it sees the type as still referencing it.
+ *
+ * This function removes:
+ * - `export type Foo = ...`
+ * - `export interface Foo { ... }`
+ * - `export type { Foo } from './module.js'`
+ * - `export type * from './module.js'`
+ * - Type specifiers in mixed exports: `export { value, type Foo }` -> `export { value }`
+ * - `import type { Foo } from './module.js'`
+ * - Type specifiers in mixed imports: `import { value, type Foo } from './module.js'` -> `import { value }`
+ *
+ * Note: Non-exported type/interface declarations are preserved as they may be
+ * used as type annotations within the code.
+ *
+ * @param ast - The Babel AST (or ParseResult) to mutate
+ */
+export declare function stripTypeExports(ast: ParseResult<_babel_types.File>): void;
+export { findReferencedIdentifiers };
+/**
+ * Performs dead code elimination on the AST, with TypeScript type stripping.
+ *
+ * This is a wrapper around babel-dead-code-elimination that first strips
+ * TypeScript type-only exports and imports. This is necessary because
+ * babel-dead-code-elimination doesn't handle type exports, which can cause
+ * imports to be retained when they're only referenced by type exports.
+ *
+ * @param ast - The Babel AST to mutate
+ * @param candidates - Optional set of identifier paths to consider for removal.
+ *                     If provided, only these identifiers will be candidates for removal.
+ *                     This should be the result of `findReferencedIdentifiers(ast)` called
+ *                     before any AST transformations.
+ */
+export declare function deadCodeElimination(ast: ParseResult<_babel_types.File>, candidates?: ReturnType<typeof findReferencedIdentifiers>): void;

package/dist/esm/ast.js

@@ -0,0 +1,98 @@
+import { parse } from "@babel/parser";
+import _generate from "@babel/generator";
+import * as t from "@babel/types";
+import { deadCodeElimination, findReferencedIdentifiers } from "babel-dead-code-elimination";
+//#region src/ast.ts
+function parseAst({ code, ...opts }) {
+	return parse(code, {
+		plugins: [
+			"jsx",
+			"typescript",
+			"explicitResourceManagement",
+			"decorators"
+		],
+		sourceType: "module",
+		...opts
+	});
+}
+var generate = _generate;
+if ("default" in generate) generate = generate.default;
+function generateFromAst(ast, opts) {
+	return generate(ast, opts ? {
+		importAttributesKeyword: "with",
+		sourceMaps: true,
+		...opts
+	} : void 0);
+}
+/**
+* Strips TypeScript type-only exports and imports from an AST.
+*
+* This is necessary because babel-dead-code-elimination doesn't handle
+* TypeScript type exports/imports. When a type export references an import
+* that pulls in server-only code, the dead code elimination won't remove
+* that import because it sees the type as still referencing it.
+*
+* This function removes:
+* - `export type Foo = ...`
+* - `export interface Foo { ... }`
+* - `export type { Foo } from './module'`
+* - `export type * from './module'`
+* - Type specifiers in mixed exports: `export { value, type Foo }` -> `export { value }`
+* - `import type { Foo } from './module'`
+* - Type specifiers in mixed imports: `import { value, type Foo } from './module'` -> `import { value }`
+*
+* Note: Non-exported type/interface declarations are preserved as they may be
+* used as type annotations within the code.
+*
+* @param ast - The Babel AST (or ParseResult) to mutate
+*/
+function stripTypeExports(ast) {
+	ast.program.body = ast.program.body.filter((node) => {
+		if (t.isExportNamedDeclaration(node)) {
+			if (node.exportKind === "type") return false;
+			if (node.specifiers.length > 0) {
+				node.specifiers = node.specifiers.filter((specifier) => {
+					if (t.isExportSpecifier(specifier)) return specifier.exportKind !== "type";
+					return true;
+				});
+				if (node.specifiers.length === 0 && !node.declaration) return false;
+			}
+		}
+		if (t.isExportAllDeclaration(node)) {
+			if (node.exportKind === "type") return false;
+		}
+		if (t.isImportDeclaration(node)) {
+			if (node.importKind === "type") return false;
+			if (node.specifiers.length > 0) {
+				node.specifiers = node.specifiers.filter((specifier) => {
+					if (t.isImportSpecifier(specifier)) return specifier.importKind !== "type";
+					return true;
+				});
+				if (node.specifiers.length === 0) return false;
+			}
+		}
+		return true;
+	});
+}
+/**
+* Performs dead code elimination on the AST, with TypeScript type stripping.
+*
+* This is a wrapper around babel-dead-code-elimination that first strips
+* TypeScript type-only exports and imports. This is necessary because
+* babel-dead-code-elimination doesn't handle type exports, which can cause
+* imports to be retained when they're only referenced by type exports.
+*
+* @param ast - The Babel AST to mutate
+* @param candidates - Optional set of identifier paths to consider for removal.
+*                     If provided, only these identifiers will be candidates for removal.
+*                     This should be the result of `findReferencedIdentifiers(ast)` called
+*                     before any AST transformations.
+*/
+function deadCodeElimination$1(ast, candidates) {
+	stripTypeExports(ast);
+	deadCodeElimination(ast, candidates);
+}
+//#endregion
+export { deadCodeElimination$1 as deadCodeElimination, findReferencedIdentifiers, generateFromAst, parseAst, stripTypeExports };
+
+//# sourceMappingURL=ast.js.map

package/dist/esm/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","names":[],"sources":["../../src/ast.ts"],"sourcesContent":["import { parse } from '@babel/parser'\nimport _generate from '@babel/generator'\nimport * as t from '@babel/types'\nimport {\n  deadCodeElimination as _deadCodeElimination,\n  findReferencedIdentifiers,\n} from 'babel-dead-code-elimination'\nimport type { GeneratorOptions, GeneratorResult } from '@babel/generator'\nimport type { ParseResult, ParserOptions } from '@babel/parser'\nimport type * as _babel_types from '@babel/types'\n\nexport type ParseAstOptions = ParserOptions & {\n  code: string\n}\n\nexport type ParseAstResult = ParseResult<_babel_types.File>\nexport function parseAst({ code, ...opts }: ParseAstOptions): ParseAstResult {\n  return parse(code, {\n    plugins: [\n      'jsx',\n      'typescript',\n      'explicitResourceManagement',\n      'decorators', // required for Angular and other decorator-based code\n    ],\n    sourceType: 'module',\n    ...opts,\n  })\n}\n\nlet generate = _generate\n\nif ('default' in generate) {\n  generate = generate.default as typeof generate\n}\ntype GenerateFromAstOptions = GeneratorOptions &\n  Required<Pick<GeneratorOptions, 'sourceFileName' | 'filename'>>\nexport function generateFromAst(\n  ast: _babel_types.Node,\n  opts?: GenerateFromAstOptions,\n): GeneratorResult {\n  return generate(\n    ast,\n    opts\n      ? { importAttributesKeyword: 'with', sourceMaps: true, ...opts }\n      : undefined,\n  )\n}\nexport type { GeneratorResult } from '@babel/generator'\n\n/**\n * Strips TypeScript type-only exports and imports from an AST.\n *\n * This is necessary because babel-dead-code-elimination doesn't handle\n * TypeScript type exports/imports. When a type export references an import\n * that pulls in server-only code, the dead code elimination won't remove\n * that import because it sees the type as still referencing it.\n *\n * This function removes:\n * - `export type Foo = ...`\n * - `export interface Foo { ... }`\n * - `export type { Foo } from './module'`\n * - `export type * from './module'`\n * - Type specifiers in mixed exports: `export { value, type Foo }` -> `export { value }`\n * - `import type { Foo } from './module'`\n * - Type specifiers in mixed imports: `import { value, type Foo } from './module'` -> `import { value }`\n *\n * Note: Non-exported type/interface declarations are preserved as they may be\n * used as type annotations within the code.\n *\n * @param ast - The Babel AST (or ParseResult) to mutate\n */\nexport function stripTypeExports(ast: ParseResult<_babel_types.File>): void {\n  // Filter the program body to remove type-only nodes\n  ast.program.body = ast.program.body.filter((node) => {\n    // Handle export declarations\n    if (t.isExportNamedDeclaration(node)) {\n      // Remove entire export if it's a type-only export\n      // e.g., `export type Foo = string`, `export interface Bar {}`, `export type { X } from './y'`\n      if (node.exportKind === 'type') {\n        return false\n      }\n\n      // For value exports with mixed specifiers, filter out type-only specifiers\n      // e.g., `export { value, type TypeOnly }` -> `export { value }`\n      if (node.specifiers.length > 0) {\n        node.specifiers = node.specifiers.filter((specifier) => {\n          if (t.isExportSpecifier(specifier)) {\n            return specifier.exportKind !== 'type'\n          }\n          return true\n        })\n\n        // If all specifiers were removed, remove the entire export declaration\n        // (unless it has a declaration like `export const x = 1`)\n        if (node.specifiers.length === 0 && !node.declaration) {\n          return false\n        }\n      }\n    }\n\n    // Handle type-only export-all declarations\n    // e.g., `export type * from './module'`\n    if (t.isExportAllDeclaration(node)) {\n      if (node.exportKind === 'type') {\n        return false\n      }\n    }\n\n    // Handle import declarations\n    if (t.isImportDeclaration(node)) {\n      // Remove entire import if it's a type-only import\n      // e.g., `import type { Foo } from './module'`\n      if (node.importKind === 'type') {\n        return false\n      }\n\n      // For value imports with mixed specifiers, filter out type-only specifiers\n      // e.g., `import { value, type TypeOnly } from './module'` -> `import { value }`\n      if (node.specifiers.length > 0) {\n        node.specifiers = node.specifiers.filter((specifier) => {\n          if (t.isImportSpecifier(specifier)) {\n            return specifier.importKind !== 'type'\n          }\n          return true\n        })\n\n        // If all specifiers were removed, remove the entire import declaration\n        if (node.specifiers.length === 0) {\n          return false\n        }\n      }\n    }\n\n    return true\n  })\n}\n\n// Re-export findReferencedIdentifiers from babel-dead-code-elimination\nexport { findReferencedIdentifiers }\n\n/**\n * Performs dead code elimination on the AST, with TypeScript type stripping.\n *\n * This is a wrapper around babel-dead-code-elimination that first strips\n * TypeScript type-only exports and imports. This is necessary because\n * babel-dead-code-elimination doesn't handle type exports, which can cause\n * imports to be retained when they're only referenced by type exports.\n *\n * @param ast - The Babel AST to mutate\n * @param candidates - Optional set of identifier paths to consider for removal.\n *                     If provided, only these identifiers will be candidates for removal.\n *                     This should be the result of `findReferencedIdentifiers(ast)` called\n *                     before any AST transformations.\n */\nexport function deadCodeElimination(\n  ast: ParseResult<_babel_types.File>,\n  candidates?: ReturnType<typeof findReferencedIdentifiers>,\n): void {\n  // First strip TypeScript type-only exports and imports\n  stripTypeExports(ast)\n\n  // Then run the original dead code elimination\n  _deadCodeElimination(ast, candidates)\n}\n"],"mappings":";;;;;AAgBA,SAAgB,SAAS,EAAE,MAAM,GAAG,QAAyC;AAC3E,QAAO,MAAM,MAAM;EACjB,SAAS;GACP;GACA;GACA;GACA;GACD;EACD,YAAY;EACZ,GAAG;EACJ,CAAC;;AAGJ,IAAI,WAAW;AAEf,IAAI,aAAa,SACf,YAAW,SAAS;AAItB,SAAgB,gBACd,KACA,MACiB;AACjB,QAAO,SACL,KACA,OACI;EAAE,yBAAyB;EAAQ,YAAY;EAAM,GAAG;EAAM,GAC9D,KAAA,EACL;;;;;;;;;;;;;;;;;;;;;;;;AA0BH,SAAgB,iBAAiB,KAA2C;AAE1E,KAAI,QAAQ,OAAO,IAAI,QAAQ,KAAK,QAAQ,SAAS;AAEnD,MAAI,EAAE,yBAAyB,KAAK,EAAE;AAGpC,OAAI,KAAK,eAAe,OACtB,QAAO;AAKT,OAAI,KAAK,WAAW,SAAS,GAAG;AAC9B,SAAK,aAAa,KAAK,WAAW,QAAQ,cAAc;AACtD,SAAI,EAAE,kBAAkB,UAAU,CAChC,QAAO,UAAU,eAAe;AAElC,YAAO;MACP;AAIF,QAAI,KAAK,WAAW,WAAW,KAAK,CAAC,KAAK,YACxC,QAAO;;;AAOb,MAAI,EAAE,uBAAuB,KAAK;OAC5B,KAAK,eAAe,OACtB,QAAO;;AAKX,MAAI,EAAE,oBAAoB,KAAK,EAAE;AAG/B,OAAI,KAAK,eAAe,OACtB,QAAO;AAKT,OAAI,KAAK,WAAW,SAAS,GAAG;AAC9B,SAAK,aAAa,KAAK,WAAW,QAAQ,cAAc;AACtD,SAAI,EAAE,kBAAkB,UAAU,CAChC,QAAO,UAAU,eAAe;AAElC,YAAO;MACP;AAGF,QAAI,KAAK,WAAW,WAAW,EAC7B,QAAO;;;AAKb,SAAO;GACP;;;;;;;;;;;;;;;;AAoBJ,SAAgB,sBACd,KACA,YACM;AAEN,kBAAiB,IAAI;AAGrB,qBAAqB,KAAK,WAAW"}

package/dist/esm/copy-files-plugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+export declare function copyFilesPlugin({ fromDir, toDir, pattern, }: {
+    pattern?: string | Array<string>;
+    fromDir: string;
+    toDir: string;
+}): Plugin;

package/dist/esm/copy-files-plugin.js

@@ -0,0 +1,23 @@
+import { copyFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "pathe";
+import { glob } from "tinyglobby";
+//#region src/copy-files-plugin.ts
+function copyFilesPlugin({ fromDir, toDir, pattern = "**" }) {
+	return {
+		name: "copy-files",
+		async writeBundle() {
+			const entries = await glob(pattern, { cwd: fromDir });
+			if (entries.length === 0) throw new Error(`No files found matching pattern "${pattern}" in directory "${fromDir}"`);
+			for (const entry of entries) {
+				const srcPath = join(fromDir, entry);
+				const destPath = join(toDir, entry);
+				await mkdir(dirname(destPath), { recursive: true });
+				await copyFile(srcPath, destPath);
+			}
+		}
+	};
+}
+//#endregion
+export { copyFilesPlugin };
+
+//# sourceMappingURL=copy-files-plugin.js.map

package/dist/esm/copy-files-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-files-plugin.js","names":[],"sources":["../../src/copy-files-plugin.ts"],"sourcesContent":["import { copyFile, mkdir } from 'node:fs/promises'\nimport { dirname, join } from 'pathe'\nimport { glob } from 'tinyglobby'\nimport type { Plugin } from 'vite'\n\nexport function copyFilesPlugin({\n  fromDir,\n  toDir,\n  pattern = '**',\n}: {\n  pattern?: string | Array<string>\n  fromDir: string\n  toDir: string\n}): Plugin {\n  return {\n    name: 'copy-files',\n    async writeBundle() {\n      const entries = await glob(pattern, { cwd: fromDir })\n      if (entries.length === 0) {\n        throw new Error(\n          `No files found matching pattern \"${pattern}\" in directory \"${fromDir}\"`,\n        )\n      }\n\n      for (const entry of entries) {\n        const srcPath = join(fromDir, entry)\n        const destPath = join(toDir, entry)\n        // Ensure the destination directory exists\n        await mkdir(dirname(destPath), { recursive: true })\n        await copyFile(srcPath, destPath)\n      }\n    },\n  }\n}\n"],"mappings":";;;;AAKA,SAAgB,gBAAgB,EAC9B,SACA,OACA,UAAU,QAKD;AACT,QAAO;EACL,MAAM;EACN,MAAM,cAAc;GAClB,MAAM,UAAU,MAAM,KAAK,SAAS,EAAE,KAAK,SAAS,CAAC;AACrD,OAAI,QAAQ,WAAW,EACrB,OAAM,IAAI,MACR,oCAAoC,QAAQ,kBAAkB,QAAQ,GACvE;AAGH,QAAK,MAAM,SAAS,SAAS;IAC3B,MAAM,UAAU,KAAK,SAAS,MAAM;IACpC,MAAM,WAAW,KAAK,OAAO,MAAM;AAEnC,UAAM,MAAM,QAAQ,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC;AACnD,UAAM,SAAS,SAAS,SAAS;;;EAGtC"}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { parseAst, generateFromAst, deadCodeElimination, findReferencedIdentifiers, stripTypeExports, } from './ast.js';
+export type { ParseAstOptions, ParseAstResult, GeneratorResult } from './ast.js';
+export { logDiff } from './logger.js';
+export { copyFilesPlugin } from './copy-files-plugin.js';

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+import { deadCodeElimination, findReferencedIdentifiers, generateFromAst, parseAst, stripTypeExports } from "./ast.js";
+import { logDiff } from "./logger.js";
+import { copyFilesPlugin } from "./copy-files-plugin.js";
+export { copyFilesPlugin, deadCodeElimination, findReferencedIdentifiers, generateFromAst, logDiff, parseAst, stripTypeExports };

package/dist/esm/logger.d.ts

@@ -0,0 +1 @@
+export declare function logDiff(oldStr: string, newStr: string): void;

package/dist/esm/logger.js

@@ -0,0 +1,48 @@
+import ansis from "ansis";
+import { diffWords } from "diff";
+//#region src/logger.ts
+function logDiff(oldStr, newStr) {
+	const differences = diffWords(oldStr, newStr);
+	let output = "";
+	let unchangedLines = "";
+	function processUnchangedLines(lines) {
+		const lineArray = lines.split("\n");
+		if (lineArray.length > 4) return [
+			ansis.dim(lineArray[0]),
+			ansis.dim(lineArray[1]),
+			"",
+			ansis.dim.bold(`... (${lineArray.length - 4} lines) ...`),
+			"",
+			ansis.dim(lineArray[lineArray.length - 2]),
+			ansis.dim(lineArray[lineArray.length - 1])
+		].join("\n");
+		return ansis.dim(lines);
+	}
+	differences.forEach((part, index) => {
+		const nextPart = differences[index + 1];
+		if (part.added) {
+			if (unchangedLines) {
+				output += processUnchangedLines(unchangedLines);
+				unchangedLines = "";
+			}
+			output += ansis.green.bold(part.value);
+			if (nextPart?.removed) output += " ";
+		} else if (part.removed) {
+			if (unchangedLines) {
+				output += processUnchangedLines(unchangedLines);
+				unchangedLines = "";
+			}
+			output += ansis.red.bold(part.value);
+			if (nextPart?.added) output += " ";
+		} else unchangedLines += part.value;
+	});
+	if (unchangedLines) output += processUnchangedLines(unchangedLines);
+	if (output) {
+		console.log("\nDiff:");
+		console.log(output + "\n\n");
+	} else console.log("No changes");
+}
+//#endregion
+export { logDiff };
+
+//# sourceMappingURL=logger.js.map

package/dist/esm/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":[],"sources":["../../src/logger.ts"],"sourcesContent":["import ansis from 'ansis'\nimport { diffWords } from 'diff'\n\nexport function logDiff(oldStr: string, newStr: string) {\n  const differences = diffWords(oldStr, newStr)\n\n  let output = ''\n  let unchangedLines = ''\n\n  function processUnchangedLines(lines: string): string {\n    const lineArray = lines.split('\\n')\n    if (lineArray.length > 4) {\n      return [\n        ansis.dim(lineArray[0]),\n        ansis.dim(lineArray[1]),\n        '',\n        ansis.dim.bold(`... (${lineArray.length - 4} lines) ...`),\n        '',\n        ansis.dim(lineArray[lineArray.length - 2]),\n        ansis.dim(lineArray[lineArray.length - 1]),\n      ].join('\\n')\n    }\n    return ansis.dim(lines)\n  }\n\n  differences.forEach((part, index) => {\n    const nextPart = differences[index + 1]\n\n    if (part.added) {\n      if (unchangedLines) {\n        output += processUnchangedLines(unchangedLines)\n        unchangedLines = ''\n      }\n      output += ansis.green.bold(part.value)\n      if (nextPart?.removed) output += ' '\n    } else if (part.removed) {\n      if (unchangedLines) {\n        output += processUnchangedLines(unchangedLines)\n        unchangedLines = ''\n      }\n      output += ansis.red.bold(part.value)\n      if (nextPart?.added) output += ' '\n    } else {\n      unchangedLines += part.value\n    }\n  })\n\n  // Process any remaining unchanged lines at the end\n  if (unchangedLines) {\n    output += processUnchangedLines(unchangedLines)\n  }\n\n  if (output) {\n    console.log('\\nDiff:')\n    console.log(output + '\\n\\n')\n  } else {\n    console.log('No changes')\n  }\n}\n"],"mappings":";;;AAGA,SAAgB,QAAQ,QAAgB,QAAgB;CACtD,MAAM,cAAc,UAAU,QAAQ,OAAO;CAE7C,IAAI,SAAS;CACb,IAAI,iBAAiB;CAErB,SAAS,sBAAsB,OAAuB;EACpD,MAAM,YAAY,MAAM,MAAM,KAAK;AACnC,MAAI,UAAU,SAAS,EACrB,QAAO;GACL,MAAM,IAAI,UAAU,GAAG;GACvB,MAAM,IAAI,UAAU,GAAG;GACvB;GACA,MAAM,IAAI,KAAK,QAAQ,UAAU,SAAS,EAAE,aAAa;GACzD;GACA,MAAM,IAAI,UAAU,UAAU,SAAS,GAAG;GAC1C,MAAM,IAAI,UAAU,UAAU,SAAS,GAAG;GAC3C,CAAC,KAAK,KAAK;AAEd,SAAO,MAAM,IAAI,MAAM;;AAGzB,aAAY,SAAS,MAAM,UAAU;EACnC,MAAM,WAAW,YAAY,QAAQ;AAErC,MAAI,KAAK,OAAO;AACd,OAAI,gBAAgB;AAClB,cAAU,sBAAsB,eAAe;AAC/C,qBAAiB;;AAEnB,aAAU,MAAM,MAAM,KAAK,KAAK,MAAM;AACtC,OAAI,UAAU,QAAS,WAAU;aACxB,KAAK,SAAS;AACvB,OAAI,gBAAgB;AAClB,cAAU,sBAAsB,eAAe;AAC/C,qBAAiB;;AAEnB,aAAU,MAAM,IAAI,KAAK,KAAK,MAAM;AACpC,OAAI,UAAU,MAAO,WAAU;QAE/B,mBAAkB,KAAK;GAEzB;AAGF,KAAI,eACF,WAAU,sBAAsB,eAAe;AAGjD,KAAI,QAAQ;AACV,UAAQ,IAAI,UAAU;AACtB,UAAQ,IAAI,SAAS,OAAO;OAE5B,SAAQ,IAAI,aAAa"}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@benjavicente/router-utils",
+  "version": "1.161.6",
+  "description": "Modern and scalable routing for React applications",
+  "author": "Tanner Linsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/router.git",
+    "directory": "packages/router-utils"
+  },
+  "homepage": "https://tanstack.com/router",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "keywords": [
+    "react",
+    "location",
+    "router",
+    "routing",
+    "async",
+    "async router",
+    "typescript"
+  ],
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=20.19"
+  },
+  "dependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/generator": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/types": "^7.28.5",
+    "ansis": "^4.1.0",
+    "babel-dead-code-elimination": "^1.0.12",
+    "diff": "^8.0.2",
+    "pathe": "^2.0.3",
+    "tinyglobby": "^0.2.15"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__generator": "^7.27.0",
+    "@types/diff": "^7.0.2",
+    "vite": "*",
+    "@types/node": ">=20"
+  },
+  "scripts": {
+    "clean": "rimraf ./dist && rimraf ./coverage",
+    "test:eslint": "eslint ./src",
+    "test:types": "pnpm run \"/^test:types:ts[0-9]{2}$/\"",
+    "test:types:ts55": "node ../../node_modules/typescript55/lib/tsc.js",
+    "test:types:ts56": "node ../../node_modules/typescript56/lib/tsc.js",
+    "test:types:ts57": "node ../../node_modules/typescript57/lib/tsc.js",
+    "test:types:ts58": "node ../../node_modules/typescript58/lib/tsc.js",
+    "test:types:ts59": "node ../../node_modules/typescript59/lib/tsc.js",
+    "test:types:ts60": "tsc",
+    "test:unit": "exit 0; vitest --typecheck",
+    "test:build": "publint --strict && attw --ignore-rules no-resolution --pack .",
+    "build": "vite build"
+  }
+}

package/src/ast.ts

@@ -0,0 +1,164 @@
+import { parse } from '@babel/parser'
+import _generate from '@babel/generator'
+import * as t from '@babel/types'
+import {
+  deadCodeElimination as _deadCodeElimination,
+  findReferencedIdentifiers,
+} from 'babel-dead-code-elimination'
+import type { GeneratorOptions, GeneratorResult } from '@babel/generator'
+import type { ParseResult, ParserOptions } from '@babel/parser'
+import type * as _babel_types from '@babel/types'
+
+export type ParseAstOptions = ParserOptions & {
+  code: string
+}
+
+export type ParseAstResult = ParseResult<_babel_types.File>
+export function parseAst({ code, ...opts }: ParseAstOptions): ParseAstResult {
+  return parse(code, {
+    plugins: [
+      'jsx',
+      'typescript',
+      'explicitResourceManagement',
+      'decorators', // required for Angular and other decorator-based code
+    ],
+    sourceType: 'module',
+    ...opts,
+  })
+}
+
+let generate = _generate
+
+if ('default' in generate) {
+  generate = generate.default as typeof generate
+}
+type GenerateFromAstOptions = GeneratorOptions &
+  Required<Pick<GeneratorOptions, 'sourceFileName' | 'filename'>>
+export function generateFromAst(
+  ast: _babel_types.Node,
+  opts?: GenerateFromAstOptions,
+): GeneratorResult {
+  return generate(
+    ast,
+    opts
+      ? { importAttributesKeyword: 'with', sourceMaps: true, ...opts }
+      : undefined,
+  )
+}
+export type { GeneratorResult } from '@babel/generator'
+
+/**
+ * Strips TypeScript type-only exports and imports from an AST.
+ *
+ * This is necessary because babel-dead-code-elimination doesn't handle
+ * TypeScript type exports/imports. When a type export references an import
+ * that pulls in server-only code, the dead code elimination won't remove
+ * that import because it sees the type as still referencing it.
+ *
+ * This function removes:
+ * - `export type Foo = ...`
+ * - `export interface Foo { ... }`
+ * - `export type { Foo } from './module'`
+ * - `export type * from './module'`
+ * - Type specifiers in mixed exports: `export { value, type Foo }` -> `export { value }`
+ * - `import type { Foo } from './module'`
+ * - Type specifiers in mixed imports: `import { value, type Foo } from './module'` -> `import { value }`
+ *
+ * Note: Non-exported type/interface declarations are preserved as they may be
+ * used as type annotations within the code.
+ *
+ * @param ast - The Babel AST (or ParseResult) to mutate
+ */
+export function stripTypeExports(ast: ParseResult<_babel_types.File>): void {
+  // Filter the program body to remove type-only nodes
+  ast.program.body = ast.program.body.filter((node) => {
+    // Handle export declarations
+    if (t.isExportNamedDeclaration(node)) {
+      // Remove entire export if it's a type-only export
+      // e.g., `export type Foo = string`, `export interface Bar {}`, `export type { X } from './y'`
+      if (node.exportKind === 'type') {
+        return false
+      }
+
+      // For value exports with mixed specifiers, filter out type-only specifiers
+      // e.g., `export { value, type TypeOnly }` -> `export { value }`
+      if (node.specifiers.length > 0) {
+        node.specifiers = node.specifiers.filter((specifier) => {
+          if (t.isExportSpecifier(specifier)) {
+            return specifier.exportKind !== 'type'
+          }
+          return true
+        })
+
+        // If all specifiers were removed, remove the entire export declaration
+        // (unless it has a declaration like `export const x = 1`)
+        if (node.specifiers.length === 0 && !node.declaration) {
+          return false
+        }
+      }
+    }
+
+    // Handle type-only export-all declarations
+    // e.g., `export type * from './module'`
+    if (t.isExportAllDeclaration(node)) {
+      if (node.exportKind === 'type') {
+        return false
+      }
+    }
+
+    // Handle import declarations
+    if (t.isImportDeclaration(node)) {
+      // Remove entire import if it's a type-only import
+      // e.g., `import type { Foo } from './module'`
+      if (node.importKind === 'type') {
+        return false
+      }
+
+      // For value imports with mixed specifiers, filter out type-only specifiers
+      // e.g., `import { value, type TypeOnly } from './module'` -> `import { value }`
+      if (node.specifiers.length > 0) {
+        node.specifiers = node.specifiers.filter((specifier) => {
+          if (t.isImportSpecifier(specifier)) {
+            return specifier.importKind !== 'type'
+          }
+          return true
+        })
+
+        // If all specifiers were removed, remove the entire import declaration
+        if (node.specifiers.length === 0) {
+          return false
+        }
+      }
+    }
+
+    return true
+  })
+}
+
+// Re-export findReferencedIdentifiers from babel-dead-code-elimination
+export { findReferencedIdentifiers }
+
+/**
+ * Performs dead code elimination on the AST, with TypeScript type stripping.
+ *
+ * This is a wrapper around babel-dead-code-elimination that first strips
+ * TypeScript type-only exports and imports. This is necessary because
+ * babel-dead-code-elimination doesn't handle type exports, which can cause
+ * imports to be retained when they're only referenced by type exports.
+ *
+ * @param ast - The Babel AST to mutate
+ * @param candidates - Optional set of identifier paths to consider for removal.
+ *                     If provided, only these identifiers will be candidates for removal.
+ *                     This should be the result of `findReferencedIdentifiers(ast)` called
+ *                     before any AST transformations.
+ */
+export function deadCodeElimination(
+  ast: ParseResult<_babel_types.File>,
+  candidates?: ReturnType<typeof findReferencedIdentifiers>,
+): void {
+  // First strip TypeScript type-only exports and imports
+  stripTypeExports(ast)
+
+  // Then run the original dead code elimination
+  _deadCodeElimination(ast, candidates)
+}

package/src/copy-files-plugin.ts

@@ -0,0 +1,34 @@
+import { copyFile, mkdir } from 'node:fs/promises'
+import { dirname, join } from 'pathe'
+import { glob } from 'tinyglobby'
+import type { Plugin } from 'vite'
+
+export function copyFilesPlugin({
+  fromDir,
+  toDir,
+  pattern = '**',
+}: {
+  pattern?: string | Array<string>
+  fromDir: string
+  toDir: string
+}): Plugin {
+  return {
+    name: 'copy-files',
+    async writeBundle() {
+      const entries = await glob(pattern, { cwd: fromDir })
+      if (entries.length === 0) {
+        throw new Error(
+          `No files found matching pattern "${pattern}" in directory "${fromDir}"`,
+        )
+      }
+
+      for (const entry of entries) {
+        const srcPath = join(fromDir, entry)
+        const destPath = join(toDir, entry)
+        // Ensure the destination directory exists
+        await mkdir(dirname(destPath), { recursive: true })
+        await copyFile(srcPath, destPath)
+      }
+    },
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export {
+  parseAst,
+  generateFromAst,
+  deadCodeElimination,
+  findReferencedIdentifiers,
+  stripTypeExports,
+} from './ast'
+export type { ParseAstOptions, ParseAstResult, GeneratorResult } from './ast'
+export { logDiff } from './logger'
+
+export { copyFilesPlugin } from './copy-files-plugin'

package/src/logger.ts

@@ -0,0 +1,59 @@
+import ansis from 'ansis'
+import { diffWords } from 'diff'
+
+export function logDiff(oldStr: string, newStr: string) {
+  const differences = diffWords(oldStr, newStr)
+
+  let output = ''
+  let unchangedLines = ''
+
+  function processUnchangedLines(lines: string): string {
+    const lineArray = lines.split('\n')
+    if (lineArray.length > 4) {
+      return [
+        ansis.dim(lineArray[0]),
+        ansis.dim(lineArray[1]),
+        '',
+        ansis.dim.bold(`... (${lineArray.length - 4} lines) ...`),
+        '',
+        ansis.dim(lineArray[lineArray.length - 2]),
+        ansis.dim(lineArray[lineArray.length - 1]),
+      ].join('\n')
+    }
+    return ansis.dim(lines)
+  }
+
+  differences.forEach((part, index) => {
+    const nextPart = differences[index + 1]
+
+    if (part.added) {
+      if (unchangedLines) {
+        output += processUnchangedLines(unchangedLines)
+        unchangedLines = ''
+      }
+      output += ansis.green.bold(part.value)
+      if (nextPart?.removed) output += ' '
+    } else if (part.removed) {
+      if (unchangedLines) {
+        output += processUnchangedLines(unchangedLines)
+        unchangedLines = ''
+      }
+      output += ansis.red.bold(part.value)
+      if (nextPart?.added) output += ' '
+    } else {
+      unchangedLines += part.value
+    }
+  })
+
+  // Process any remaining unchanged lines at the end
+  if (unchangedLines) {
+    output += processUnchangedLines(unchangedLines)
+  }
+
+  if (output) {
+    console.log('\nDiff:')
+    console.log(output + '\n\n')
+  } else {
+    console.log('No changes')
+  }
+}