@codefast/cli 0.9.0 → 0.10.0

package/dist/pack-slim/domain/transform.d.ts

@@ -0,0 +1,69 @@
+/** Pure transforms that slim a package's manifest and dist for publish. */
+/**
+ * What slimming one manifest removed.
+ */
+interface ManifestSlimReport {
+    readonly filesSrcRemoved: boolean;
+    readonly exportsSourceRemoved: number;
+    readonly importsSourceRemoved: number;
+    readonly importsUnshippedRemoved: number;
+    readonly scriptsRemoved: number;
+    readonly devDependenciesRemoved: number;
+    readonly changed: boolean;
+}
+/**
+ * The slimmed manifest paired with the report of what it dropped.
+ *
+ * @since 0.8.1
+ */
+export interface SlimManifestResult {
+    readonly manifest: Record<string, unknown>;
+    readonly report: ManifestSlimReport;
+}
+/**
+ * The result of stripping the `sourceMappingURL` directive from an emitted file's text.
+ *
+ * @since 0.8.1
+ */
+export interface StripCommentResult {
+    readonly text: string;
+    readonly stripped: boolean;
+}
+/**
+ * Whether a dist entry is a source-map sidecar (`*.map`).
+ *
+ * @since 0.8.1
+ */
+export declare function isSourceMapFile(fileName: string): boolean;
+/**
+ * Whether a dist entry is an emitted file that may carry a `sourceMappingURL` directive.
+ *
+ * @since 0.8.1
+ */
+export declare function isMapAnnotatedFile(fileName: string): boolean;
+/**
+ * Whether a script name is an install or publish lifecycle hook, with or without its `pre`/`post` prefix.
+ *
+ * @remarks Publish hooks stay because `pnpm publish` runs them right after pack-slim; install hooks stay because a
+ * consumer's package manager runs them.
+ *
+ * @since 0.9.0
+ */
+export declare function isLifecycleScript(name: string): boolean;
+/**
+ * Produces a publish manifest carrying only what a consumer's `tsc` and Node read.
+ *
+ * @remarks Operates on a structural clone, so the caller's manifest is left intact. A consumer never enables `source`
+ * and resolves `#/` through `types`/`default` to `dist`, so dropping the source lane, the `imports` left pointing
+ * outside `files`, the scripts that are not lifecycle hooks, and `devDependencies` leaves the published surface whole.
+ *
+ * @since 0.8.1
+ */
+export declare function slimPublishManifest(manifest: Record<string, unknown>): SlimManifestResult;
+/**
+ * Strips every `sourceMappingURL` directive line from an emitted file's text.
+ *
+ * @since 0.8.1
+ */
+export declare function stripSourceMappingComment(text: string): StripCommentResult;
+export {};

package/dist/pack-slim/domain/types.d.ts

@@ -0,0 +1,46 @@
+/** Stats and progress types for a pack-slim run. */
+/**
+ * The outcome of slimming one workspace package.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimPackageStats {
+    name: string;
+    path: string;
+    skipped: boolean;
+    skipReason: string;
+    error: string | null;
+    filesSrcRemoved: boolean;
+    exportsSourceRemoved: number;
+    importsSourceRemoved: number;
+    importsUnshippedRemoved: number;
+    scriptsRemoved: number;
+    devDependenciesRemoved: number;
+    mapFilesDeleted: number;
+    sourceCommentsStripped: number;
+    changed: boolean;
+}
+/**
+ * The aggregate stats of a pack-slim run across every targeted package.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimRunStats {
+    packagesFound: number;
+    packagesProcessed: number;
+    packagesSkipped: number;
+    packagesErrored: number;
+    packagesChanged: number;
+    totalMapFilesDeleted: number;
+    packageDetails: Array<PackSlimPackageStats>;
+}
+/**
+ * The progress events a pack-slim run emits as it works through the packages.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimProgressListener {
+    onBanner?(): void;
+    onPackageComplete?(stats: PackSlimPackageStats, ordinal: number, total: number): void;
+    onComplete?(stats: PackSlimRunStats, elapsedSeconds: number): void;
+}

package/dist/pack-slim/output.d.ts

@@ -0,0 +1,15 @@
+import type { PackSlimPackageStats, PackSlimProgressListener, PackSlimRunStats } from "#/pack-slim/domain/types";
+/**
+ * A progress listener that renders pack-slim run events as human-readable CLI lines.
+ *
+ * @since 0.8.1
+ */
+export declare class PackSlimProgressPresenter implements PackSlimProgressListener {
+    private dryRun;
+    configure(options: {
+        readonly dryRun: boolean;
+    }): void;
+    onBanner(): void;
+    onPackageComplete(stats: PackSlimPackageStats, ordinal: number, total: number): void;
+    onComplete(stats: PackSlimRunStats, elapsedSeconds: number): void;
+}

package/dist/pack-slim/sync.d.ts

@@ -0,0 +1,23 @@
+import { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+import type { PackSlimRunRequest } from "#/pack-slim/cli-schema";
+import type { PackSlimProgressListener, PackSlimRunStats } from "#/pack-slim/domain/types";
+/**
+ * A pack-slim run request paired with an optional progress listener.
+ *
+ * @since 0.8.1
+ */
+export type PackSlimRunInput = PackSlimRunRequest & {
+    readonly listener?: PackSlimProgressListener | undefined;
+};
+/**
+ * Slims every published package's manifest and build output for publish and returns the aggregate stats.
+ *
+ * @remarks Meant to run on an ephemeral CI checkout right before `changeset publish`: it rewrites `package.json` down to
+ * what a consumer reads, drops `dist` source maps, and clears their now-dangling `sourceMappingURL` directives, so the
+ * tarball ships only `dist` runtime and types. Private packages are skipped because `changeset publish` never publishes them.
+ *
+ * @since 0.8.1
+ */
+export declare function runPackSlim(fs: FilesystemPort, input: PackSlimRunInput): Promise<Result<PackSlimRunStats, AppError>>;

package/dist/pack-slim/sync.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { AppError, messageFrom } from "#/core/errors";
 import { err, ok } from "#/core/result";
 import { listWorkspacePackageDirectories } from "#/core/workspace/resolver";
-import { DIST_DIR, PACKAGE_JSON } from "#/mirror/domain/constants";
+import { distDirName, packageJsonFileName } from "#/core/workspace/well-known-files";
 import { isMapAnnotatedFile, isSourceMapFile, slimPublishManifest, stripSourceMappingComment, } from "#/pack-slim/domain/transform";
 /**
  * Slims every published package's manifest and build output for publish and returns the aggregate stats.
@@ -47,7 +47,7 @@ export async function runPackSlim(fs, input) {
 async function resolveTargets(fs, rootDir, packageFilter) {
     if (packageFilter !== undefined) {
         const packageDir = path.resolve(rootDir, packageFilter);
-        if (!fs.existsSync(path.join(packageDir, PACKAGE_JSON))) {
+        if (!fs.existsSync(path.join(packageDir, packageJsonFileName))) {
             throw new Error(`No package.json under "${packageFilter}"`);
         }
         return [packageDir];
@@ -56,7 +56,7 @@ async function resolveTargets(fs, rootDir, packageFilter) {
     return [...layout.packageDirectoryPathsAbsolute].sort((left, right) => left.localeCompare(right));
 }
 async function slimWorkspacePackage(fs, packageDir, write) {
-    const packageJsonPath = path.join(packageDir, PACKAGE_JSON);
+    const packageJsonPath = path.join(packageDir, packageJsonFileName);
     const pkgStats = {
         name: path.basename(packageDir),
         path: packageDir,
@@ -103,7 +103,7 @@ async function slimWorkspacePackage(fs, packageDir, write) {
         if (report.changed && write) {
             await fs.writeFile(packageJsonPath, `${JSON.stringify(slimmed, null, 2)}\n`, "utf8");
         }
-        await pruneDist(fs, path.join(packageDir, DIST_DIR), write, pkgStats);
+        await pruneDist(fs, path.join(packageDir, distDirName), write, pkgStats);
         pkgStats.changed = report.changed || pkgStats.mapFilesDeleted > 0 || pkgStats.sourceCommentsStripped > 0;
     }
     catch (caughtError) {

package/dist/pack-slim/working-tree.d.ts

@@ -0,0 +1,20 @@
+import { AppError } from "#/core/errors";
+import type { Result } from "#/core/result";
+/**
+ * Whether git's tracked-only porcelain output reports any uncommitted change.
+ *
+ * @remarks The output is read with `--untracked-files=no`, so untracked and gitignored paths (like the freshly built
+ * `dist`) never appear — any non-blank line is a staged or unstaged change to a tracked file.
+ *
+ * @since 0.8.1
+ */
+export declare function hasUncommittedTrackedChanges(porcelainOutput: string): boolean;
+/**
+ * Refuses when the git working tree carries uncommitted tracked changes, so a destructive slim never lands on real work.
+ *
+ * @remarks pack-slim rewrites tracked `package.json` files and deletes build output; its result must never be committed.
+ * A caller passing `--force` skips this, and `--dry-run` never reaches it because it writes nothing.
+ *
+ * @since 0.8.1
+ */
+export declare function ensureWorkingTreeClean(rootDir: string): Result<void, AppError>;

package/dist/tag/cli-result.d.ts

@@ -0,0 +1,7 @@
+import type { TagSyncResult } from "#/tag/domain/types";
+/**
+ * Maps a tag run's result to the process exit code.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function exitCodeForTagSyncResult(result: TagSyncResult): number;

package/dist/tag/cli-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { TagSyncRunRequest } from "#/tag/sync";
+/**
+ * Zod schema validating a `TagSyncRunRequest`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const tagSyncRunRequestSchema: z.ZodType<TagSyncRunRequest>;

package/dist/tag/command.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+/**
+ * Creates the `tag` subcommand, which stamps `@since` tags on exported declarations.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function createTagCommand(): Command;

package/dist/tag/domain/types.d.ts

@@ -0,0 +1,111 @@
+import type { CodefastConfig } from "#/core/config/schema";
+/**
+ * Per-file outcome of a tag run.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagFileResult = {
+    filePath: string;
+    taggedDeclarations: number;
+    changed: boolean;
+};
+/**
+ * Outcome of tagging one target: the version stamped and the per-file tallies.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagRunResult = {
+    version: string;
+    filesScanned: number;
+    filesChanged: number;
+    taggedDeclarations: number;
+    fileResults: Array<TagFileResult>;
+};
+/**
+ * Options for one target's tag run.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagRunOptions = {
+    write: boolean;
+};
+type TagTargetCandidateSource = "explicit-target" | "workspace-package" | "repo-src-fallback";
+/**
+ * How a resolved tag target was chosen.
+ *
+ * @since 0.3.16-canary.0
+ */
+type TagTargetSource = "explicit-target" | "workspace-package-selected-src" | "workspace-package-selected-root" | "repo-src-fallback";
+/**
+ * A candidate path a tag run may resolve into a target.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagTargetCandidate = {
+    candidatePath: string;
+    rootRelativeCandidatePath: string;
+    source: TagTargetCandidateSource;
+    packageDir: string | null;
+    packageName: string | null;
+};
+/**
+ * A directory or file a tag run will stamp, with its owning package when known.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagResolvedTarget = {
+    targetPath: string;
+    rootRelativeTargetPath: string;
+    source: TagTargetSource;
+    packageDir: string | null;
+    packageName: string | null;
+};
+/**
+ * One target's execution outcome, carrying either its run result or its error.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagTargetExecutionResult = {
+    target: TagResolvedTarget;
+    targetExists: boolean;
+    runError: string | null;
+    result: TagRunResult | null;
+};
+/**
+ * Callbacks a tag run invokes as each target starts and completes.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface TagProgressListener {
+    onTargetStarted: (target: TagResolvedTarget) => void;
+    onTargetCompleted: (target: TagResolvedTarget, result: TagTargetExecutionResult) => void;
+}
+/**
+ * Aggregate outcome of a tag run across every selected target.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagSyncResult = {
+    mode: "applied" | "dry-run";
+    selectedTargets: Array<TagResolvedTarget>;
+    skippedPackages: Array<string>;
+    targetResults: Array<TagTargetExecutionResult>;
+    filesScanned: number;
+    filesChanged: number;
+    taggedDeclarations: number;
+    versionSummary: string;
+    distinctVersions: Array<string>;
+    modifiedFiles: Array<string>;
+    hookError: string | null;
+};
+/**
+ * Everything the `tag` action needs resolved before a run: root, config, and target path.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface TagCommandPrelude {
+    readonly rootDir: string;
+    readonly config: CodefastConfig;
+    readonly resolvedTargetPath: string | undefined;
+}
+export {};

package/dist/tag/output.d.ts

@@ -0,0 +1,17 @@
+import type { TagProgressListener, TagResolvedTarget, TagSyncResult, TagTargetExecutionResult } from "#/tag/domain/types";
+/**
+ * A progress listener that prints a line as each tag target starts and completes.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare class TagSyncProgressPresenter implements TagProgressListener {
+    onTargetStarted(target: TagResolvedTarget): void;
+    onTargetCompleted(target: TagResolvedTarget, result: TagTargetExecutionResult): void;
+    private static formatProgress;
+}
+/**
+ * Prints a tag run's target table, warnings, and summary, and returns the exit code.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function presentTagSyncResult(result: TagSyncResult, rootDir: string): number;

package/dist/tag/prepare.d.ts

@@ -0,0 +1,13 @@
+import type { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+import type { TagCommandPrelude } from "#/tag/domain/types";
+/**
+ * Resolves the repo root, config, and optional target path into the prelude a tag run starts from.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function prepareTagSync(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<TagCommandPrelude, AppError>>;

package/dist/tag/prepare.js

@@ -1,6 +1,6 @@
 import { loadCodefastConfig } from "#/core/config";
 import { ok } from "#/core/result";
-import { findRepoRoot } from "#/core/workspace/resolver";
+import { resolveProjectRoot } from "#/core/workspace/resolver";
 import { resolveProvidedTagTargetPath } from "#/tag/resolve-target-path";
 /**
  * Resolves the repo root, config, and optional target path into the prelude a tag run starts from.
@@ -10,7 +10,7 @@ import { resolveProvidedTagTargetPath } from "#/tag/resolve-target-path";
 export async function prepareTagSync(fs, args) {
     let rootDir;
     try {
-        rootDir = findRepoRoot(args.currentWorkingDirectory, fs);
+        rootDir = resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir;
     }
     catch {
         rootDir = args.currentWorkingDirectory;

package/dist/tag/resolve-target-path.d.ts

@@ -0,0 +1,10 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Canonicalizes the user-provided target path, or returns `undefined` when none was given.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function resolveProvidedTagTargetPath(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): string | undefined;

package/dist/tag/since-writer.d.ts

@@ -0,0 +1,32 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { TagFileResult } from "#/tag/domain/types";
+/**
+ * The writer that adds missing `@since` tags to a file's exported declarations.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare class TagSinceWriter {
+    private readonly fs;
+    private readonly sinceDocumentationTag;
+    constructor(fs: FilesystemPort);
+    applySinceTagsToFile(filePath: string, version: string, write: boolean): TagFileResult;
+    /**
+     * The taggable declaration a top-level statement introduces, resolving the
+     * `export … <decl>` wrapper to the wrapper node — its `start` sits at `export`,
+     * matching `ts.getStart` on a modifier-bearing declaration.
+     */
+    private taggableDeclarationOf;
+    private declarationNames;
+    private addDeclarationName;
+    private collectLocalNamedDeclarations;
+    private collectExportedDeclarations;
+    /**
+     * The JSDoc block documenting `anchor`: the nearest preceding `/** … *\/` whose
+     * gap to the declaration is whitespace only, mirroring TS comment attachment.
+     */
+    private associatedJsDoc;
+    private jsDocHasSinceTag;
+    private makeJSDocSinceLine;
+    private makeSinceOnlyJSDocBlock;
+    private makeDeclarationSinceLine;
+}

package/dist/tag/sync.d.ts

@@ -0,0 +1,42 @@
+import { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+import type { TagProgressListener, TagSyncResult, TagTargetCandidate } from "#/tag/domain/types";
+/**
+ * The inputs a tag run is invoked with.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagSyncRunRequest = {
+    rootDir: string;
+    write: boolean;
+    json?: boolean | undefined;
+    targetPath?: string | undefined;
+    skipPackages?: Array<string> | undefined;
+    config?: unknown;
+};
+/**
+ * A run request paired with an optional progress listener.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagSyncExecutionInput = TagSyncRunRequest & {
+    readonly listener?: TagProgressListener | undefined;
+};
+/**
+ * Runs the tag sync across the selected targets and returns the aggregate result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runTagSync(fs: FilesystemPort, input: TagSyncExecutionInput): Promise<Result<TagSyncResult, AppError>>;
+/**
+ * Partition tag target candidates into those to tag and those to skip, matching
+ * each candidate's package name against `skipPackages` as glob patterns.
+ * Candidates without a package name (e.g. an explicit-target path) are never skipped.
+ *
+ * @since 0.5.0-canary.0
+ */
+export declare function filterSkippedCandidates(targetCandidates: Array<TagTargetCandidate>, skipPackages: ReadonlyArray<string> | undefined): {
+    includedCandidates: Array<TagTargetCandidate>;
+    skippedPackages: Array<string>;
+};

package/dist/tag/target-candidates.d.ts

@@ -0,0 +1,8 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { TagTargetCandidate } from "#/tag/domain/types";
+/**
+ * Resolves the candidate targets for a tag run: the explicit target, or the discovered workspace packages.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function resolveTagTargetCandidates(fs: FilesystemPort, rootDir: string, explicitTarget: string | undefined): Promise<Array<TagTargetCandidate>>;

package/dist/tag/target-candidates.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { z } from "zod";
 import { listWorkspacePackageDirectories } from "#/core/workspace/resolver";
-const packageJsonFileName = "package.json";
+import { packageJsonFileName } from "#/core/workspace/well-known-files";
 const packageJsonNameSchema = z.looseObject({
     name: z.string().min(1).optional(),
 });

package/dist/tag/target-runner.d.ts

@@ -0,0 +1,8 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { TagRunOptions, TagRunResult } from "#/tag/domain/types";
+/**
+ * Stamps `@since` tags across one target's TypeScript files and returns the run result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runTagOnTarget(fs: FilesystemPort, targetPath: string, opts: TagRunOptions): TagRunResult;

package/dist/tag/version-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Returns the `version` of the nearest enclosing `package.json` above a target path.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function resolveNearestPackageVersion(fs: FilesystemPort, targetPath: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Developer CLI for the Codefast monorepo (arrange, audit, mirror, pack-slim, tag)",
   "keywords": [
     "cli",
@@ -31,11 +31,22 @@
     "LICENSE"
   ],
   "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "imports": {
     "#/*": {
+      "types": "./dist/*.d.ts",
       "default": "./dist/*.js"
     }
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },

package/dist/audit/domain/react-imports.js

@@ -1,91 +0,0 @@
-import { parseSync } from "oxc-parser";
-function isOxcNode(value) {
-    return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-function isIdentifierNamed(node, name) {
-    return isOxcNode(node) && node.type === "Identifier" && node.name === name;
-}
-/**
- * Scans one TypeScript source for React import-policy violations.
- *
- * @remarks Three violation kinds: `import * as React`, a default `React` import (type-only
- * included), and — only when no import binds `React` — an implicit `React.*` UMD-global type
- * reference, which tsc accepts silently through the `export as namespace React` in `@types/react`.
- *
- * @since 0.8.0
- */
-export function auditReactImportSource(filePath, sourceText) {
-    const { program } = parseSync(filePath, sourceText);
-    const statements = program.body;
-    const violations = [];
-    let bindsReact = false;
-    for (const statement of statements) {
-        if (statement.type !== "ImportDeclaration") {
-            continue;
-        }
-        const source = statement.source;
-        if (!isOxcNode(source) || source.value !== "react") {
-            continue;
-        }
-        const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers.filter(isOxcNode) : [];
-        bindsReact ||= specifiers.some((specifier) => isIdentifierNamed(specifier.local, "React"));
-        for (const specifier of specifiers) {
-            if (specifier.type === "ImportNamespaceSpecifier") {
-                violations.push({
-                    line: lineOfOffset(sourceText, statement.start),
-                    raw: firstLineOf(sourceText.slice(statement.start, statement.end)),
-                    reason: 'namespace React import — import members by name from "react"',
-                });
-            }
-            else if (specifier.type === "ImportDefaultSpecifier") {
-                violations.push({
-                    line: lineOfOffset(sourceText, statement.start),
-                    raw: firstLineOf(sourceText.slice(statement.start, statement.end)),
-                    reason: 'default React import — import members by name from "react"',
-                });
-            }
-        }
-    }
-    // A bound `React` means the import itself is flagged above; qualified names under it are
-    // symptoms, not extra findings.
-    if (!bindsReact) {
-        collectUmdGlobalReferences(program, sourceText, violations);
-    }
-    violations.sort((a, b) => a.line - b.line);
-    return violations;
-}
-function collectUmdGlobalReferences(node, sourceText, violations) {
-    if (node.type === "TSQualifiedName" && isIdentifierNamed(node.left, "React")) {
-        violations.push({
-            line: lineOfOffset(sourceText, node.start),
-            raw: sourceText.slice(node.start, node.end),
-            reason: 'implicit React.* UMD global — add import type { … } from "react"',
-        });
-        return;
-    }
-    for (const value of Object.values(node)) {
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (isOxcNode(item)) {
-                    collectUmdGlobalReferences(item, sourceText, violations);
-                }
-            }
-        }
-        else if (isOxcNode(value)) {
-            collectUmdGlobalReferences(value, sourceText, violations);
-        }
-    }
-}
-function lineOfOffset(sourceText, offset) {
-    let line = 1;
-    for (let index = 0; index < offset; index++) {
-        if (sourceText.charCodeAt(index) === 10) {
-            line++;
-        }
-    }
-    return line;
-}
-function firstLineOf(text) {
-    const newlineIndex = text.indexOf("\n");
-    return newlineIndex === -1 ? text : text.slice(0, newlineIndex);
-}