@trackunit/react-components 3.12.4-alpha-10f2d9d2ab3.0 → 4.0.0

package/migrations/assets/react-router-components/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@trackunit/react-router-components",
+  "version": "1.0.1",
+  "repository": "https://github.com/Trackunit/manager",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "engines": {
+    "node": ">=24.x"
+  },
+  "dependencies": {
+    "@trackunit/css-class-variance-utilities": "2.6.7",
+    "@trackunit/i18n-library-translation": "2.12.6",
+    "@trackunit/react-components": "4.0.0",
+    "@trackunit/react-drawer": "2.14.7",
+    "@trackunit/shared-utils": "1.22.7",
+    "dequal": "^2.0.3",
+    "zod": "^3.25.76"
+  },
+  "peerDependencies": {
+    "@tanstack/react-router": "^1.114.29",
+    "react": "^19.0.0"
+  },
+  "migrations": "./migrations.json"
+}

package/migrations/utils/move-named-imports.js

@@ -0,0 +1,409 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logManualReview = exports.moveNamedImports = void 0;
+const devkit_1 = require("@nx/devkit");
+const ts = __importStar(require("typescript"));
+const jsx_utils_1 = require("./jsx-utils");
+const MOCK_OBJECTS = new Set(["vi", "jest"]);
+const MOCK_METHODS = new Set([
+    "mock",
+    "doMock",
+    "unmock",
+    "doUnmock",
+    "importActual",
+    "importMock",
+    "requireActual",
+    "requireMock",
+]);
+const toRenameMap = (names) => Array.isArray(names) ? new Map(names.map(name => [name, name])) : new Map(Object.entries(names));
+const parseSource = (filePath, content) => ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts.ScriptKind.TS : ts.ScriptKind.TSX);
+const isModule = (node, moduleName) => node !== undefined &&
+    (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) &&
+    node.text === moduleName;
+/** Renders `moduleName` with the quote style of an existing specifier. */
+const quoteLike = (specifier, moduleName) => {
+    const quote = specifier.getText().startsWith("'") ? "'" : '"';
+    return `${quote}${moduleName}${quote}`;
+};
+const renderSpecifier = ({ imported, local, isTypeOnly }, withTypePrefix) => `${withTypePrefix && isTypeOnly ? "type " : ""}${imported === local ? imported : `${imported} as ${local}`}`;
+const statementTerminator = (statement) => (statement.getText().endsWith(";") ? ";" : "");
+const lineOf = (sourceFile, node) => sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+/** `true` when `node` is a property-like key (`a.X`, `{ X: 1 }`, `<C X="" />`) rather than a reference to a binding. */
+const isPropertyKey = (node) => {
+    const parent = node.parent;
+    if (ts.isPropertyAccessExpression(parent) || ts.isQualifiedName(parent)) {
+        return ts.isPropertyAccessExpression(parent) ? parent.name === node : parent.right === node;
+    }
+    if (ts.isBindingElement(parent))
+        return parent.propertyName === node;
+    if (ts.isPropertyAssignment(parent) ||
+        ts.isPropertyDeclaration(parent) ||
+        ts.isPropertySignature(parent) ||
+        ts.isMethodDeclaration(parent) ||
+        ts.isMethodSignature(parent) ||
+        ts.isGetAccessorDeclaration(parent) ||
+        ts.isSetAccessorDeclaration(parent) ||
+        ts.isEnumMember(parent) ||
+        ts.isJsxAttribute(parent)) {
+        return parent.name === node;
+    }
+    return false;
+};
+/** `true` when `node` declares a new binding (variable, parameter, function, class, type...). */
+const isBindingDeclaration = (node) => {
+    const parent = node.parent;
+    if (ts.isBindingElement(parent))
+        return parent.name === node;
+    if (ts.isVariableDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isFunctionDeclaration(parent) ||
+        ts.isFunctionExpression(parent) ||
+        ts.isClassDeclaration(parent) ||
+        ts.isClassExpression(parent) ||
+        ts.isInterfaceDeclaration(parent) ||
+        ts.isTypeAliasDeclaration(parent) ||
+        ts.isEnumDeclaration(parent) ||
+        ts.isTypeParameterDeclaration(parent) ||
+        ts.isImportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent) ||
+        ts.isImportEqualsDeclaration(parent)) {
+        return parent.name === node;
+    }
+    return false;
+};
+/** Import and re-export statements are rewritten as a whole, so their identifiers are never edited one by one. */
+const isInsideModuleStatement = (node) => ts.findAncestor(node, ancestor => ts.isImportDeclaration(ancestor) || (ts.isExportDeclaration(ancestor) && ancestor.moduleSpecifier !== undefined)) !== undefined;
+const collectIdentifiers = (sourceFile) => {
+    const identifiers = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node))
+            identifiers.push(node);
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return identifiers;
+};
+/**
+ * Edits that rename every reference to the local binding `oldName` to
+ * `newName`, or `null` when that can't be done safely (the new name is
+ * already used in the file, or `oldName` is redeclared and might be shadowed).
+ */
+const renameReferenceEdits = (sourceFile, identifiers, oldName, newName) => {
+    if (identifiers.some(id => id.text === newName))
+        return null;
+    const outside = identifiers.filter(id => id.text === oldName && !isInsideModuleStatement(id));
+    if (outside.some(isBindingDeclaration))
+        return null;
+    const edits = [];
+    for (const id of outside) {
+        if (isPropertyKey(id))
+            continue;
+        const start = id.getStart(sourceFile);
+        const end = id.getEnd();
+        const parent = id.parent;
+        if (ts.isShorthandPropertyAssignment(parent)) {
+            edits.push({ start, end, text: `${oldName}: ${newName}` });
+        }
+        else if (ts.isExportSpecifier(parent)) {
+            if (parent.propertyName === undefined)
+                edits.push({ start, end, text: `${newName} as ${oldName}` });
+            else if (parent.propertyName === id)
+                edits.push({ start, end, text: newName });
+        }
+        else {
+            edits.push({ start, end, text: newName });
+        }
+    }
+    return edits;
+};
+/**
+ * Usages of `fromModule` the codemod can't rewrite statically. They are only
+ * reported when the file references a moved name at all, so e.g. a
+ * `vi.mock(fromModule, ...)` in a spec that never touches a moved name is not
+ * noise. `export *` is always reported: the moved names silently drop out of it.
+ */
+const findManualReviewItems = (sourceFile, identifiers, fromModule, toModule, renames) => {
+    const items = [];
+    const file = sourceFile.fileName;
+    const mentionsMovedName = identifiers.some(id => renames.has(id.text)) || sourceFile.text.split(/["'`]/).some(chunk => renames.has(chunk));
+    const movedList = [...renames.keys()].join(", ");
+    const hint = `moved names (${movedList}) now come from "${toModule}"`;
+    const report = (node, what) => {
+        items.push({ file, line: lineOf(sourceFile, node), reason: `${what} of "${fromModule}"; ${hint}` });
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && isModule(node.moduleSpecifier, fromModule)) {
+            const bindings = node.importClause?.namedBindings;
+            if (bindings !== undefined && ts.isNamespaceImport(bindings) && mentionsMovedName) {
+                report(node, `namespace import \`* as ${bindings.name.text}\``);
+            }
+        }
+        else if (ts.isExportDeclaration(node) && isModule(node.moduleSpecifier, fromModule)) {
+            if (node.exportClause === undefined)
+                report(node, "`export *`");
+            else if (ts.isNamespaceExport(node.exportClause))
+                report(node, "`export * as`");
+        }
+        else if (ts.isImportEqualsDeclaration(node) && mentionsMovedName) {
+            const reference = node.moduleReference;
+            if (ts.isExternalModuleReference(reference) && isModule(reference.expression, fromModule)) {
+                report(node, "`import = require()`");
+            }
+        }
+        else if (ts.isImportTypeNode(node) && mentionsMovedName) {
+            const argument = node.argument;
+            if (ts.isLiteralTypeNode(argument) && isModule(argument.literal, fromModule))
+                report(node, "`import()` type");
+        }
+        else if (ts.isCallExpression(node) && mentionsMovedName && isModule(node.arguments[0], fromModule)) {
+            const callee = node.expression;
+            if (callee.kind === ts.SyntaxKind.ImportKeyword) {
+                report(node, "dynamic import()");
+            }
+            else if (ts.isIdentifier(callee) && callee.text === "require") {
+                report(node, "require()");
+            }
+            else if (ts.isPropertyAccessExpression(callee) &&
+                ts.isIdentifier(callee.expression) &&
+                MOCK_OBJECTS.has(callee.expression.text) &&
+                MOCK_METHODS.has(callee.name.text)) {
+                report(node, `${callee.expression.text}.${callee.name.text}()`);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return items;
+};
+const findTargetImport = (sourceFile, toModule, typeOnly) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !isModule(statement.moduleSpecifier, toModule))
+            continue;
+        const clause = statement.importClause;
+        if (clause === undefined || clause.isTypeOnly !== typeOnly)
+            continue;
+        const bindings = clause.namedBindings;
+        if (bindings === undefined || !ts.isNamedImports(bindings))
+            continue;
+        return { statement, elements: bindings.elements, additions: [] };
+    }
+    return null;
+};
+const specifierKey = ({ imported, local }) => `${imported} as ${local}`;
+const specifierOf = (element, parentTypeOnly) => ({
+    imported: (element.propertyName ?? element.name).text,
+    local: element.name.text,
+    isTypeOnly: parentTypeOnly || element.isTypeOnly,
+});
+const rewriteFile = (filePath, content, { fromModule, toModule }, renames) => {
+    const sourceFile = parseSource(filePath, content);
+    const identifiers = collectIdentifiers(sourceFile);
+    const manualReview = findManualReviewItems(sourceFile, identifiers, fromModule, toModule, renames);
+    const edits = [];
+    const valueTarget = findTargetImport(sourceFile, toModule, false);
+    const typeTarget = findTargetImport(sourceFile, toModule, true);
+    const targetFor = (spec) => {
+        if (!spec.isTypeOnly)
+            return valueTarget;
+        return typeTarget ?? valueTarget;
+    };
+    const replaceStatement = (statement, kept, added) => {
+        const parts = [...(kept === null ? [] : [kept]), ...added];
+        const start = statement.getStart(sourceFile);
+        let end = statement.getEnd();
+        if (parts.length === 0) {
+            if (content.startsWith("\r\n", end))
+                end += 2;
+            else if (content.startsWith("\n", end))
+                end += 1;
+            const leading = content.slice(statement.getFullStart(), start);
+            if (leading.includes("eslint-disable")) {
+                manualReview.push({
+                    file: filePath,
+                    line: lineOf(sourceFile, statement),
+                    reason: `removed import of "${fromModule}" had an eslint-disable comment, which now applies to the next line`,
+                });
+            }
+        }
+        edits.push({ start, end, text: parts.join("\n") });
+    };
+    const createdImports = new Map();
+    const deferredImports = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement) && isModule(statement.moduleSpecifier, fromModule)) {
+            const clause = statement.importClause;
+            const bindings = clause?.namedBindings;
+            if (clause === undefined || bindings === undefined || !ts.isNamedImports(bindings))
+                continue;
+            const moved = bindings.elements.filter(element => renames.has((element.propertyName ?? element.name).text));
+            if (moved.length === 0)
+                continue;
+            const kept = bindings.elements.filter(element => !moved.includes(element));
+            const createdKind = clause.isTypeOnly;
+            const addCreated = (spec) => {
+                const created = createdImports.get(createdKind) ?? { anchor: statement, specs: [] };
+                createdImports.set(createdKind, created);
+                if (!created.specs.some(existing => specifierKey(existing) === specifierKey(spec)))
+                    created.specs.push(spec);
+            };
+            for (const element of moved) {
+                const original = specifierOf(element, clause.isTypeOnly);
+                const newName = renames.get(original.imported) ?? original.imported;
+                let local = original.local;
+                if (newName !== original.imported && original.local === original.imported) {
+                    const renameEdits = renameReferenceEdits(sourceFile, identifiers, original.local, newName);
+                    if (renameEdits !== null) {
+                        edits.push(...renameEdits);
+                        local = newName;
+                    }
+                }
+                const spec = { imported: newName, local, isTypeOnly: original.isTypeOnly };
+                const target = targetFor(spec);
+                if (target === null) {
+                    addCreated(spec);
+                    continue;
+                }
+                const existing = new Set([
+                    ...target.elements.map(e => specifierKey(specifierOf(e, false))),
+                    ...target.additions.map(specifierKey),
+                ]);
+                if (!existing.has(specifierKey(spec)))
+                    target.additions.push(spec);
+            }
+            const terminator = statementTerminator(statement);
+            const defaultName = clause.name?.text;
+            const keptText = kept.length === 0 && defaultName === undefined
+                ? null
+                : `import ${clause.isTypeOnly ? "type " : ""}${[
+                    ...(defaultName === undefined ? [] : [defaultName]),
+                    ...(kept.length === 0 ? [] : [`{ ${kept.map(e => e.getText(sourceFile)).join(", ")} }`]),
+                ].join(", ")} from ${statement.moduleSpecifier.getText(sourceFile)}${terminator}`;
+            deferredImports.push({ statement, keptText });
+        }
+        else if (ts.isExportDeclaration(statement) &&
+            isModule(statement.moduleSpecifier, fromModule) &&
+            statement.moduleSpecifier !== undefined &&
+            statement.exportClause !== undefined &&
+            ts.isNamedExports(statement.exportClause)) {
+            const elements = statement.exportClause.elements;
+            const moved = elements.filter(element => renames.has((element.propertyName ?? element.name).text));
+            if (moved.length === 0)
+                continue;
+            const kept = elements.filter(element => !moved.includes(element));
+            const typePrefix = statement.isTypeOnly ? "type " : "";
+            const terminator = statementTerminator(statement);
+            const specs = moved.map(element => {
+                const imported = (element.propertyName ?? element.name).text;
+                return renderSpecifier({ imported: renames.get(imported) ?? imported, local: element.name.text, isTypeOnly: element.isTypeOnly }, true);
+            });
+            replaceStatement(statement, kept.length === 0
+                ? null
+                : `export ${typePrefix}{ ${kept.map(e => e.getText(sourceFile)).join(", ")} } from ${statement.moduleSpecifier.getText(sourceFile)}${terminator}`, [
+                `export ${typePrefix}{ ${specs.join(", ")} } from ${quoteLike(statement.moduleSpecifier, toModule)}${terminator}`,
+            ]);
+        }
+    }
+    for (const { statement, keptText } of deferredImports) {
+        const createdText = [...createdImports.entries()]
+            .filter(([, created]) => created.anchor === statement)
+            .map(([typeOnly, created]) => `import ${typeOnly ? "type " : ""}{ ${created.specs
+            .map(spec => renderSpecifier(spec, !typeOnly))
+            .join(", ")} } from ${quoteLike(statement.moduleSpecifier, toModule)}${statementTerminator(statement)}`);
+        replaceStatement(statement, keptText, createdText);
+    }
+    for (const target of [valueTarget, typeTarget]) {
+        if (target === null || target.additions.length === 0)
+            continue;
+        const typeOnly = target.statement.importClause?.isTypeOnly === true;
+        const bindings = target.statement.importClause?.namedBindings;
+        if (bindings === undefined)
+            continue;
+        const merged = [
+            ...target.elements.map(e => e.getText(sourceFile)),
+            ...target.additions.map(spec => renderSpecifier(spec, !typeOnly)),
+        ];
+        edits.push({ start: bindings.getStart(sourceFile), end: bindings.getEnd(), text: `{ ${merged.join(", ")} }` });
+    }
+    if (edits.length === 0)
+        return { content, manualReview };
+    edits.sort((a, b) => b.start - a.start);
+    let updated = content;
+    for (const { start, end, text } of edits) {
+        updated = updated.slice(0, start) + text + updated.slice(end);
+    }
+    return { content: updated, manualReview };
+};
+/**
+ * Moves named imports and named re-exports of `names` from `fromModule` to
+ * `toModule` across every `.ts`/`.tsx`/`.jsx` file in the tree.
+ *
+ * - Mixed imports are split; names that didn't move stay on `fromModule`.
+ * - Aliases (`as`), `import type` and inline `type` modifiers are preserved.
+ * - Moved names are merged into an existing named import of `toModule`, or
+ *   else into one new import per kind (value / `import type`).
+ * - With a rename record, an unaliased import has its references renamed too;
+ *   when that isn't safe (name clash or shadowing) it is imported as
+ *   `{ NewName as OldName }` instead. Re-exports keep their public name.
+ * - Namespace imports, `export *`, dynamic `import()`, `require()` and
+ *   `vi`/`jest` mocks of `fromModule` are left untouched and returned in
+ *   `manualReview`, never skipped silently.
+ *
+ * Synchronous and format-free, so it can run inside a `run-migrations`
+ * migration; callers format changed files themselves (e.g. `formatFiles`).
+ */
+const moveNamedImports = (tree, options) => {
+    const renames = toRenameMap(options.names);
+    const changedFiles = [];
+    const manualReview = [];
+    (0, jsx_utils_1.visitTsFiles)(tree, options.fromModule, (filePath, content) => {
+        const result = rewriteFile(filePath, content, options, renames);
+        manualReview.push(...result.manualReview);
+        if (result.content !== content)
+            changedFiles.push(filePath);
+        return result.content;
+    });
+    return { changedFiles, manualReview };
+};
+exports.moveNamedImports = moveNamedImports;
+/** Logs each manual-review item as a warning, prefixed with the migration name. */
+const logManualReview = (migrationName, items) => {
+    for (const { file, line, reason } of items) {
+        devkit_1.logger.warn(`  ${migrationName}: manual review needed at ${file}:${line} - ${reason}`);
+    }
+};
+exports.logManualReview = logManualReview;
+//# sourceMappingURL=move-named-imports.js.map

package/migrations/utils/package-json-utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCompanionVersion = exports.findPackageJsonsDeclaring = exports.ensureDependency = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_fs_1 = require("node:fs");
+/** Root package name of the manager monorepo, where `@trackunit/*` versions are owned by CI. */
+const MANAGER_WORKSPACE_PACKAGE_NAME = "@trackunit/manager";
+/**
+ * Adds `packageName@range` to a package.json unless it is already declared
+ * in `dependencies` or `devDependencies` (an existing entry is never
+ * changed). Does nothing in the manager monorepo itself. Doesn't install;
+ * the consumer has to re-install afterwards.
+ */
+const ensureDependency = (tree, options) => {
+    const { packageName, range, besidePackage, packageJsonPath = "package.json" } = options;
+    if (!tree.exists(packageJsonPath))
+        return "no-package-json";
+    const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+    if (packageJson.name === MANAGER_WORKSPACE_PACKAGE_NAME)
+        return "manager-workspace";
+    if (packageJson.dependencies?.[packageName] !== undefined ||
+        packageJson.devDependencies?.[packageName] !== undefined) {
+        return "already-present";
+    }
+    const asDevDependency = besidePackage !== undefined &&
+        packageJson.dependencies?.[besidePackage] === undefined &&
+        packageJson.devDependencies?.[besidePackage] !== undefined;
+    const entry = { [packageName]: range };
+    (0, devkit_1.addDependenciesToPackageJson)(tree, asDevDependency ? {} : entry, asDevDependency ? entry : {}, packageJsonPath, true);
+    return "added";
+};
+exports.ensureDependency = ensureDependency;
+/**
+ * Every package.json except the root one (and anything under
+ * `node_modules`) that declares `packageName` as a dependency, devDependency
+ * or peerDependency.
+ */
+const findPackageJsonsDeclaring = (tree, packageName) => {
+    const found = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, "/", filePath => {
+        if (filePath === "package.json" || !filePath.endsWith("/package.json"))
+            return;
+        if (filePath.startsWith("node_modules/") || filePath.includes("/node_modules/"))
+            return;
+        const packageJson = (0, devkit_1.readJson)(tree, filePath);
+        if (packageJson.dependencies?.[packageName] !== undefined ||
+            packageJson.devDependencies?.[packageName] !== undefined ||
+            packageJson.peerDependencies?.[packageName] !== undefined) {
+            found.push(filePath);
+        }
+    });
+    return found;
+};
+exports.findPackageJsonsDeclaring = findPackageJsonsDeclaring;
+/**
+ * Version of a companion package, read from the first of `candidatePaths`
+ * (absolute file-system paths, not tree paths) that is the package.json of
+ * `packageName`. Throws when none is, so a migration fails and stays pending
+ * instead of writing a wrong range.
+ */
+const readCompanionVersion = (packageName, candidatePaths) => {
+    for (const candidatePath of candidatePaths) {
+        if (!(0, node_fs_1.existsSync)(candidatePath))
+            continue;
+        const packageJson = JSON.parse((0, node_fs_1.readFileSync)(candidatePath, "utf-8"));
+        if (packageJson.name === packageName && typeof packageJson.version === "string" && packageJson.version !== "") {
+            return packageJson.version;
+        }
+    }
+    throw new Error(`Could not find the version of ${packageName}. Looked in: ${candidatePaths.join(", ")}`);
+};
+exports.readCompanionVersion = readCompanionVersion;
+//# sourceMappingURL=package-json-utils.js.map

package/migrations/v4-0-0/move-to-router-components.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveToRouterComponents = exports.resolveRouterComponentsRange = exports.ROUTER_COMPONENTS_MOVED_NAMES = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_path_1 = require("node:path");
+const jsx_utils_1 = require("../utils/jsx-utils");
+const move_named_imports_1 = require("../utils/move-named-imports");
+const package_json_utils_1 = require("../utils/package-json-utils");
+const MIGRATION_NAME = "move-to-router-components";
+const FROM_MODULE = "@trackunit/react-components";
+const TO_MODULE = "@trackunit/react-router-components";
+/** Exports that left `@trackunit/react-components` for `@trackunit/react-router-components`. */
+exports.ROUTER_COMPONENTS_MOVED_NAMES = [
+    "usePersistedState",
+    "useSearchParamSync",
+    "useCursorUrlSync",
+    "MAX_URL_LENGTH",
+    "UrlPersistenceLocation",
+    "Breadcrumb",
+];
+/**
+ * `^<version>` of `@trackunit/react-router-components`. The published
+ * package ships its package.json as a `build-migrations` asset; running from
+ * source falls back to the workspace copy.
+ */
+const resolveRouterComponentsRange = () => `^${(0, package_json_utils_1.readCompanionVersion)(TO_MODULE, [
+    (0, node_path_1.join)(__dirname, "../assets/react-router-components/package.json"),
+    (0, node_path_1.join)(__dirname, "../../../router-components/package.json"),
+])}`;
+exports.resolveRouterComponentsRange = resolveRouterComponentsRange;
+/**
+ * Moves imports and re-exports of the router-coupled hooks, constants and components from
+ * `@trackunit/react-components` to `@trackunit/react-router-components`.
+ *
+ * When something was rewritten, `@trackunit/react-router-components` is added
+ * to the root package.json next to `@trackunit/react-components` (an
+ * existing entry is kept). Per-project package.json files are only reported.
+ * Throws before touching any file when the router-components version can't be
+ * resolved, so a failed run leaves nothing half-migrated.
+ */
+const moveToRouterComponents = (tree, resolveRange = exports.resolveRouterComponentsRange) => {
+    const range = resolveRange();
+    const { changedFiles, manualReview } = (0, move_named_imports_1.moveNamedImports)(tree, {
+        fromModule: FROM_MODULE,
+        toModule: TO_MODULE,
+        names: exports.ROUTER_COMPONENTS_MOVED_NAMES,
+    });
+    (0, move_named_imports_1.logManualReview)(MIGRATION_NAME, manualReview);
+    if (changedFiles.length > 0) {
+        const result = (0, package_json_utils_1.ensureDependency)(tree, {
+            packageName: TO_MODULE,
+            range,
+            besidePackage: FROM_MODULE,
+        });
+        if (result === "added") {
+            devkit_1.logger.info(`  ${MIGRATION_NAME}: added ${TO_MODULE} to package.json; re-install dependencies (e.g. \`yarn\` or \`npm install\`) after running migrations`);
+        }
+        else if (result === "no-package-json") {
+            devkit_1.logger.warn(`  ${MIGRATION_NAME}: no root package.json found; add ${TO_MODULE} as a dependency yourself`);
+        }
+        if (result !== "manager-workspace") {
+            for (const packageJsonPath of (0, package_json_utils_1.findPackageJsonsDeclaring)(tree, FROM_MODULE)) {
+                devkit_1.logger.warn(`  ${MIGRATION_NAME}: ${packageJsonPath} declares ${FROM_MODULE}; add ${TO_MODULE} there too if that project uses the moved names`);
+            }
+        }
+    }
+    (0, jsx_utils_1.logSummary)(MIGRATION_NAME, changedFiles.length, manualReview.length);
+};
+exports.moveToRouterComponents = moveToRouterComponents;
+exports.default = exports.moveToRouterComponents;
+//# sourceMappingURL=move-to-router-components.js.map

package/migrations.json

@@ -49,6 +49,11 @@
       "version": "3.0.0",
       "description": "Replace the removed CopyableText with the Text + CopyButton pair (the displayed value stays plain text; only the button copies).",
       "implementation": "./migrations/v3-0-0/copyabletext-to-text-copybutton"
+    },
+    "v4-0-0-move-to-router-components": {
+      "version": "4.0.0",
+      "description": "Move imports of usePersistedState, useSearchParamSync, useCursorUrlSync, MAX_URL_LENGTH, UrlPersistenceLocation and Breadcrumb from @trackunit/react-components to @trackunit/react-router-components, and add @trackunit/react-router-components to the root package.json. Re-install dependencies afterwards.",
+      "implementation": "./migrations/v4-0-0/move-to-router-components"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/react-components",
-  "version": "3.12.4-alpha-10f2d9d2ab3.0",
+  "version": "4.0.0",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "migrations": "./migrations.json",
@@ -14,16 +14,15 @@
     "@floating-ui/react": "^0.26.25",
     "string-ts": "^2.0.0",
     "tailwind-merge": "^3.7.0",
-    "@trackunit/ui-design-tokens": "1.21.5-alpha-10f2d9d2ab3.0",
-    "@trackunit/css-class-variance-utilities": "2.6.5-alpha-10f2d9d2ab3.0",
-    "@trackunit/shared-utils": "1.22.5-alpha-10f2d9d2ab3.0",
-    "@trackunit/ui-icons": "1.20.5-alpha-10f2d9d2ab3.0",
+    "@trackunit/ui-design-tokens": "1.21.7",
+    "@trackunit/css-class-variance-utilities": "2.6.7",
+    "@trackunit/shared-utils": "1.22.7",
+    "@trackunit/ui-icons": "1.20.7",
     "es-toolkit": "^1.52.0",
     "@tanstack/react-virtual": "^3.14.13",
-    "dequal": "^2.0.3",
     "fflate": "^0.8.3",
     "zod": "^3.25.76",
-    "@trackunit/i18n-library-translation": "2.12.4-alpha-10f2d9d2ab3.0"
+    "@trackunit/i18n-library-translation": "2.12.6"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/components/ExternalLink/ExternalLink.d.ts

@@ -1,7 +1,7 @@
 import { MouseEventHandler, ReactElement, ReactNode } from "react";
 import { CommonProps } from "../../common/CommonProps";
-import type { Styleable } from "../../common/Styleable";
 import { Refable } from "../../common/Refable";
+import type { Styleable } from "../../common/Styleable";
 export interface ExternalLinkProps extends CommonProps, Styleable, Refable<HTMLAnchorElement> {
     /**
      * The URL to which users are redirected
@@ -37,7 +37,7 @@ export interface ExternalLinkProps extends CommonProps, Styleable, Refable<HTMLA
  * Use ExternalLink for any links that navigate to external resources outside the application (e.g., documentation, support pages, vendor sites).
  *
  * ### When not to use
- * Do not use ExternalLink for in-app navigation. Use `Link` from `@tanstack/react-router` for internal routes.
+ * Do not use ExternalLink for in-app navigation. Use `RouteLink` from `@trackunit/react-router-components` for in-app routes.
  *
  * @example Basic external link
  * ```tsx

package/src/index.d.ts

@@ -10,7 +10,6 @@ export * from "./components/Alert/Alert";
 export * from "./components/AssetIdentity/IdentityCard";
 export * from "./components/AssetIdentity/IdentityCardSkeleton";
 export * from "./components/Badge/Badge";
-export * from "./components/Breadcrumb/Breadcrumb";
 export * from "./components/buttons/Button/Button";
 export * from "./components/buttons/IconButton/IconButton";
 export * from "./components/buttons/shared/Button.variants";
@@ -126,8 +125,6 @@ export * from "./hooks/localStorage/useLocalStorageReducer";
 export * from "./hooks/localStorage/useSessionStorage";
 export * from "./hooks/localStorage/useSessionStorageReducer";
 export * from "./hooks/noPagination";
-export * from "./hooks/persistence/usePersistedState";
-export * from "./hooks/persistence/useSearchParamSync";
 export * from "./hooks/persistence/useStorageKey";
 export * from "./hooks/persistence/useStripForeignIdentityHash";
 export * from "./hooks/useBidirectionalScroll";
@@ -135,7 +132,6 @@ export * from "./hooks/useClickOutside";
 export * from "./hooks/useContainerBreakpoints";
 export * from "./hooks/useContinuousTimeout";
 export * from "./hooks/useCopyToClipboard";
-export * from "./hooks/useCursorUrlSync";
 export * from "./hooks/useDebounce";
 export * from "./hooks/useDevicePixelRatio";
 export * from "./hooks/useElevatedReducer";