@shivaedev/quality 0.7.2 → 0.8.0

package/src/cli/args.ts

@@ -1,6 +1,6 @@
 import { parseArgs } from "node:util";
 import { Result } from "effect";
-import type { WarningDetail } from "../report/render.ts";
+import type { WarningDetail } from "#report/render.ts";
 
 export type Command =
 	| { readonly _tag: "Lint"; readonly config: string | undefined; readonly warnings: WarningDetail }

package/src/cli/baseline.ts

@@ -1,13 +1,13 @@
 import { join } from "node:path";
 import { Console, Effect, type FileSystem } from "effect";
-import type { BaselineEntry } from "../baseline/format.ts";
-import { rewriteBaseline } from "../baseline/rewrite.ts";
-import { adopt, type Pruned, prune, type Scope } from "../baseline/update.ts";
-import { openSession, type Session } from "../engine/session.ts";
-import { applyRegistry } from "../exceptions/registry.ts";
-import { SetupFailure } from "../failure.ts";
-import { writeText } from "../inventory/filesystem.ts";
-import { plural } from "../report/plural.ts";
+import type { BaselineEntry } from "#baseline/format.ts";
+import { rewriteBaseline } from "#baseline/rewrite.ts";
+import { adopt, type Pruned, prune, type Scope } from "#baseline/update.ts";
+import { openSession, type Session } from "#engine/session.ts";
+import { applyRegistry } from "#exceptions/registry.ts";
+import { SetupFailure } from "#failure.ts";
+import { writeText } from "#inventory/filesystem.ts";
+import { plural } from "#report/plural.ts";
 
 const save = (session: Session, entries: readonly BaselineEntry[]): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
 	Effect.mapError(

package/src/cli/fix.ts

@@ -1,12 +1,12 @@
 import { relative } from "node:path";
 import { Console, Effect, FileSystem } from "effect";
-import { biomeReport, type Report } from "../biome/report.ts";
-import { loadConfig } from "../config/load.ts";
-import { SetupFailure } from "../failure.ts";
-import { posix } from "../inventory/ignore-scope.ts";
-import { walk } from "../inventory/walk.ts";
-import { sortManifests } from "../manifests/sorted.ts";
-import { plural } from "../report/plural.ts";
+import { biomeReport, type Report } from "#biome/report.ts";
+import { loadConfig } from "#config/load.ts";
+import { SetupFailure } from "#failure.ts";
+import { posix } from "#inventory/ignore-scope.ts";
+import { walk } from "#inventory/walk.ts";
+import { sortManifests } from "#manifests/sorted.ts";
+import { plural } from "#report/plural.ts";
 
 export const MAX_FIX_ROUNDS = 5;
 

package/src/cli/lint.ts

@@ -1,8 +1,8 @@
 import { Console, Effect, type FileSystem } from "effect";
-import { evaluate, passes } from "../engine/evaluate.ts";
-import { openSession } from "../engine/session.ts";
-import { GateFailed, type SetupFailure } from "../failure.ts";
-import { render, type WarningDetail } from "../report/render.ts";
+import { evaluate, passes } from "#engine/evaluate.ts";
+import { openSession } from "#engine/session.ts";
+import { GateFailed, type SetupFailure } from "#failure.ts";
+import { render, type WarningDetail } from "#report/render.ts";
 
 export const lint = (
 	cwd: string,

package/src/cli/migrate.ts

@@ -1,14 +1,14 @@
 import { join } from "node:path";
 import { Console, Effect, FileSystem } from "effect";
-import { encodeBaseline } from "../baseline/format.ts";
-import { convertLegacy, decodeLegacyBaseline, LEGACY_BASELINE } from "../baseline/legacy.ts";
-import { loadConfig } from "../config/load.ts";
-import { validOrFail } from "../decoded.ts";
-import { readInput } from "../engine/baseline-file.ts";
-import { scan } from "../engine/session.ts";
-import { SetupFailure } from "../failure.ts";
-import { writeText } from "../inventory/filesystem.ts";
-import { plural } from "../report/plural.ts";
+import { encodeBaseline } from "#baseline/format.ts";
+import { convertLegacy, decodeLegacyBaseline, LEGACY_BASELINE } from "#baseline/legacy.ts";
+import { loadConfig } from "#config/load.ts";
+import { validOrFail } from "#decoded.ts";
+import { readInput } from "#engine/baseline-file.ts";
+import { scan } from "#engine/session.ts";
+import { SetupFailure } from "#failure.ts";
+import { writeText } from "#inventory/filesystem.ts";
+import { plural } from "#report/plural.ts";
 
 export const migrateBaseline = (
 	cwd: string,

package/src/cli/run-main.ts

@@ -5,8 +5,8 @@ import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
 import * as NodePath from "@effect/platform-node/NodePath";
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import { Cause, Console, Effect, Exit, type FileSystem, Layer, Runtime } from "effect";
-import { SetupFailure } from "../failure.ts";
-import type { Git } from "../git/command.ts";
+import { SetupFailure } from "#failure.ts";
+import type { Git } from "#git/command.ts";
 
 const INTERRUPTED = 130;
 const COULD_NOT_RUN = 2;

package/src/cli/shrink.ts

@@ -1,9 +1,9 @@
 import { Console, Effect, type FileSystem } from "effect";
-import type { Scope } from "../baseline/update.ts";
-import type { SetupFailure } from "../failure.ts";
-import { resolveBase } from "../git/base.ts";
-import type { Git } from "../git/command.ts";
-import { changesSince } from "../git/history.ts";
+import type { Scope } from "#baseline/update.ts";
+import type { SetupFailure } from "#failure.ts";
+import { resolveBase } from "#git/base.ts";
+import type { Git } from "#git/command.ts";
+import { changesSince } from "#git/history.ts";
 import { shrinkBaseline } from "./baseline.ts";
 
 const followedMoves = (root: string, against: string | undefined): Effect.Effect<Scope, SetupFailure, Git> =>

package/src/cli.ts

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { Console, Effect } from "effect";
-import { parseCommand, USAGE } from "./cli/args.ts";
-import { writeBaseline } from "./cli/baseline.ts";
-import { fix } from "./cli/fix.ts";
-import { lint } from "./cli/lint.ts";
-import { migrateBaseline } from "./cli/migrate.ts";
-import { runMain } from "./cli/run-main.ts";
-import { pruneBaseline, tightenBaseline } from "./cli/shrink.ts";
+import { parseCommand, USAGE } from "#cli/args.ts";
+import { writeBaseline } from "#cli/baseline.ts";
+import { fix } from "#cli/fix.ts";
+import { lint } from "#cli/lint.ts";
+import { migrateBaseline } from "#cli/migrate.ts";
+import { runMain } from "#cli/run-main.ts";
+import { pruneBaseline, tightenBaseline } from "#cli/shrink.ts";
 import { SetupFailure } from "./failure.ts";
 
 const parsed = parseCommand(process.argv.slice(2));

package/src/config/decode.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
-import { type Decoded, decodeWith } from "../decoded.ts";
-import type { Rule } from "../rule.ts";
+import { type Decoded, decodeWith } from "#decoded.ts";
+import type { Rule } from "#rule.ts";
 
 const isRule = (value: unknown): value is Rule =>
 	typeof value === "object"

package/src/config/load.ts

@@ -1,9 +1,9 @@
 import { dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { Effect, FileSystem } from "effect";
-import { validOrFail } from "../decoded.ts";
-import { SetupFailure } from "../failure.ts";
-import type { InventoryScope } from "../inventory/collect.ts";
+import { validOrFail } from "#decoded.ts";
+import { SetupFailure } from "#failure.ts";
+import type { InventoryScope } from "#inventory/collect.ts";
 import { type ConfigInput, decodeConfig } from "./decode.ts";
 import { CONFIG_FILE } from "./file.ts";
 import { type ResolvedRules, resolveRules } from "./resolve.ts";

package/src/config/resolve.ts

@@ -1,10 +1,10 @@
 import { Effect } from "effect";
-import type { Level } from "../config.ts";
-import type { Decoded } from "../decoded.ts";
-import type { ActiveRule } from "../engine/run-rules.ts";
-import type { RuleIndex } from "../engine/violation.ts";
-import type { Rule } from "../rule.ts";
-import { builtInRules } from "../rules/built-in.ts";
+import type { Level } from "#config.ts";
+import type { Decoded } from "#decoded.ts";
+import type { ActiveRule } from "#engine/run-rules.ts";
+import type { RuleIndex } from "#engine/violation.ts";
+import type { Rule } from "#rule.ts";
+import { builtInRules } from "#rules/built-in.ts";
 import type { ConfigInput } from "./decode.ts";
 
 export interface ResolvedRules extends RuleIndex {

package/src/config.ts

@@ -1,5 +1,5 @@
+import type { builtInRules } from "#rules/built-in.ts";
 import type { Rule } from "./rule.ts";
-import type { builtInRules } from "./rules/built-in.ts";
 
 export type Level = "error" | "warn" | "off";
 

package/src/engine/baseline-file.ts

@@ -1,11 +1,11 @@
 import { join } from "node:path";
 import { Effect, type FileSystem } from "effect";
-import { type BaselineEntry, decodeBaseline } from "../baseline/format.ts";
-import { LEGACY_BASELINE } from "../baseline/legacy.ts";
-import type { ResolvedConfig } from "../config/load.ts";
-import { validOrFail } from "../decoded.ts";
-import { SetupFailure } from "../failure.ts";
-import { readOptionalText } from "../inventory/filesystem.ts";
+import { type BaselineEntry, decodeBaseline } from "#baseline/format.ts";
+import { LEGACY_BASELINE } from "#baseline/legacy.ts";
+import type { ResolvedConfig } from "#config/load.ts";
+import { validOrFail } from "#decoded.ts";
+import { SetupFailure } from "#failure.ts";
+import { readOptionalText } from "#inventory/filesystem.ts";
 
 export interface BaselineFile {
 	readonly entries: readonly BaselineEntry[];

package/src/engine/evaluate.ts

@@ -1,6 +1,6 @@
-import { applyBaseline, type Regression, type StaleBaselineEntry } from "../baseline/compare.ts";
-import type { BaselineEntry } from "../baseline/format.ts";
-import { applyRegistry, type RegistryEntry, type StaleRegistryEntry } from "../exceptions/registry.ts";
+import { applyBaseline, type Regression, type StaleBaselineEntry } from "#baseline/compare.ts";
+import type { BaselineEntry } from "#baseline/format.ts";
+import { applyRegistry, type RegistryEntry, type StaleRegistryEntry } from "#exceptions/registry.ts";
 import { byLocation, type RuleIndex, type Violation } from "./violation.ts";
 
 export interface Outcome {

package/src/engine/run-rules.ts

@@ -1,8 +1,8 @@
 import { isAbsolute, relative } from "node:path";
 import { Effect } from "effect";
-import { SetupFailure } from "../failure.ts";
-import { posix } from "../inventory/ignore-scope.ts";
-import type { Finding, Findings, RuleInputs } from "../rule.ts";
+import { SetupFailure } from "#failure.ts";
+import { posix } from "#inventory/ignore-scope.ts";
+import type { Finding, Findings, RuleInputs } from "#rule.ts";
 import type { ActiveLevel, Violation } from "./violation.ts";
 
 export interface ActiveRule {

package/src/engine/session.ts

@@ -1,11 +1,11 @@
 import { resolve } from "node:path";
 import { Effect, type FileSystem } from "effect";
-import { loadConfig, type ResolvedConfig } from "../config/load.ts";
-import { validOrFail } from "../decoded.ts";
-import { decodeRegistry, type RegistryEntry } from "../exceptions/registry.ts";
-import { SetupFailure } from "../failure.ts";
-import { collectInventory, type Inventory } from "../inventory/collect.ts";
-import { type FilesystemFailure, readOptionalText } from "../inventory/filesystem.ts";
+import { loadConfig, type ResolvedConfig } from "#config/load.ts";
+import { validOrFail } from "#decoded.ts";
+import { decodeRegistry, type RegistryEntry } from "#exceptions/registry.ts";
+import { SetupFailure } from "#failure.ts";
+import { collectInventory, type Inventory } from "#inventory/collect.ts";
+import { type FilesystemFailure, readOptionalText } from "#inventory/filesystem.ts";
 import { type BaselineFile, readBaseline, readInput } from "./baseline-file.ts";
 import { runRules } from "./run-rules.ts";
 import type { Violation } from "./violation.ts";

package/src/engine/violation.ts

@@ -1,5 +1,5 @@
-import type { Level } from "../config.ts";
-import type { Finding } from "../rule.ts";
+import type { Level } from "#config.ts";
+import type { Finding } from "#rule.ts";
 
 export type ActiveLevel = "error" | "warn";
 

package/src/exceptions/registry.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
-import { type Decoded, decodeWith } from "../decoded.ts";
-import { type RuleIndex, registrable, unusedEntryProblem, type Violation } from "../engine/violation.ts";
+import { type Decoded, decodeWith } from "#decoded.ts";
+import { type RuleIndex, registrable, unusedEntryProblem, type Violation } from "#engine/violation.ts";
 
 const RegistryEntry = Schema.Struct({
 	file: Schema.NonEmptyString,

package/src/git/base.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { SetupFailure } from "../failure.ts";
+import { SetupFailure } from "#failure.ts";
 import { type Git, git } from "./command.ts";
 
 export interface Base {

package/src/git/command.ts

@@ -1,6 +1,6 @@
 import { Effect, Stream } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { SetupFailure } from "../failure.ts";
+import { SetupFailure } from "#failure.ts";
 
 export interface GitResult {
 	readonly code: number;

package/src/git/history.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import type { SetupFailure } from "../failure.ts";
+import type { SetupFailure } from "#failure.ts";
 import { type Git, gitOrFail } from "./command.ts";
 
 export interface Changes {

package/src/imports/departures.ts

@@ -1,7 +1,7 @@
 import { realpathSync } from "node:fs";
 import { posix } from "node:path";
-import type { RuleInputs } from "../rule.ts";
-import { parse } from "../rules/syntax.ts";
+import type { RuleInputs } from "#rule.ts";
+import { parse } from "#rules/syntax.ts";
 import type { ImportRequest } from "./extract.ts";
 import { type Project, projectsFor } from "./projects.ts";
 import { resolveImport } from "./resolve.ts";

package/src/imports/fences/evaluate.ts

@@ -1,5 +1,5 @@
-import type { Finding } from "../../rule.ts";
-import type { ImportEdge, ImportGraph } from "../graph.ts";
+import type { ImportEdge, ImportGraph } from "#imports/graph.ts";
+import type { Finding } from "#rule.ts";
 import { type Compiler, compile, type Matcher } from "./match.ts";
 import type { Fence } from "./model.ts";
 import { labelOf, outgoing, reachedFrom } from "./reach.ts";

package/src/imports/fences/match.ts

@@ -1,5 +1,5 @@
-import { builtinName, type Endpoint, packageNameOf } from "../resolve.ts";
-import { packageOf, type WorkspacePackage } from "../workspace.ts";
+import { builtinName, type Endpoint, packageNameOf } from "#imports/resolve.ts";
+import { packageOf, type WorkspacePackage } from "#imports/workspace.ts";
 import type { Selector } from "./model.ts";
 
 export interface PolicyScope {

package/src/imports/fences/policy.ts

@@ -1,5 +1,5 @@
-import type { ImportEdge } from "../graph.ts";
-import { type Endpoint, packageNameOf } from "../resolve.ts";
+import type { ImportEdge } from "#imports/graph.ts";
+import { type Endpoint, packageNameOf } from "#imports/resolve.ts";
 import { type CompiledFence, compileFence, type FenceGraph } from "./evaluate.ts";
 import type { PolicyScope } from "./match.ts";
 import type { Chain, ExampleStep, Fence } from "./model.ts";

package/src/imports/fences/reach.ts

@@ -1,5 +1,5 @@
-import type { ImportEdge } from "../graph.ts";
-import type { Endpoint } from "../resolve.ts";
+import type { ImportEdge } from "#imports/graph.ts";
+import type { Endpoint } from "#imports/resolve.ts";
 import type { Matcher } from "./match.ts";
 
 export interface Reached {

package/src/imports/fences/vocabulary.ts

@@ -1,4 +1,4 @@
-import type { Endpoint } from "../resolve.ts";
+import type { Endpoint } from "#imports/resolve.ts";
 import { type Compiler, holdsFiles, packageNamed, trimmed } from "./match.ts";
 import type { Selector } from "./model.ts";
 

package/src/imports/generated.ts

@@ -1,8 +1,8 @@
 import { execFile } from "node:child_process";
 import { posix } from "node:path";
 import { promisify } from "node:util";
-import { emptyScope, type IgnoreScope, verdictFor, withIgnoreFile } from "../inventory/ignore-scope.ts";
-import type { RuleInputs } from "../rule.ts";
+import { emptyScope, type IgnoreScope, verdictFor, withIgnoreFile } from "#inventory/ignore-scope.ts";
+import type { RuleInputs } from "#rule.ts";
 import type { ImportGraph, UnresolvedImport } from "./graph.ts";
 
 type Reader = Pick<RuleInputs, "readText" | "root">;

package/src/imports/graph.ts

@@ -1,7 +1,7 @@
 import { realpathSync } from "node:fs";
 import { join, posix } from "node:path";
-import type { RuleInputs, SourceFile } from "../rule.ts";
-import { parse } from "../rules/syntax.ts";
+import type { RuleInputs, SourceFile } from "#rule.ts";
+import { parse } from "#rules/syntax.ts";
 import { ambientModules } from "./ambient.ts";
 import { type ImportKind, type ImportRequest, importsOf } from "./extract.ts";
 import { projectsFor } from "./projects.ts";

package/src/imports/resolve.ts

@@ -2,7 +2,7 @@ import { realpathSync } from "node:fs";
 import { isBuiltin } from "node:module";
 import { dirname, join, relative } from "node:path";
 import ts from "typescript";
-import { posix } from "../inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignore-scope.ts";
 import type { Ambient } from "./ambient.ts";
 import type { ImportRequest } from "./extract.ts";
 import type { Project } from "./projects.ts";

package/src/imports/workspace.ts

@@ -1,5 +1,5 @@
 import { posix } from "node:path";
-import type { RuleInputs } from "../rule.ts";
+import type { RuleInputs } from "#rule.ts";
 import { globMatcher } from "./glob.ts";
 import { pnpmWorkspacePatterns } from "./pnpm-workspace.ts";
 

package/src/index.ts

@@ -1,8 +1,8 @@
+export { fence } from "#imports/fences/dsl.ts";
+export type { Chain, ExampleStep, Examples, External, Fence, Target } from "#imports/fences/model.ts";
+export { anyOf, anything, external, files, folders, modules, packages, scopes, workspace } from "#imports/fences/selectors.ts";
 export type { BuiltInRules, Level, QualityConfig, RuleSetting, RuleSettings } from "./config.ts";
 export { defineConfig } from "./config.ts";
-export { fence } from "./imports/fences/dsl.ts";
-export type { Chain, ExampleStep, Examples, External, Fence, Target } from "./imports/fences/model.ts";
-export { anyOf, anything, external, files, folders, modules, packages, scopes, workspace } from "./imports/fences/selectors.ts";
 export type { Configured, Finding, Findings, Rule, RuleContext, RuleInputs, SourceFile } from "./rule.ts";
 export { defineRule } from "./rule.ts";
 export type { StandardIssue, StandardResult, StandardSchemaV1 } from "./standard-schema.ts";

package/src/inventory/collect.ts

@@ -1,7 +1,7 @@
 import { join, relative } from "node:path";
 import { Effect, FileSystem } from "effect";
 import ignore from "ignore";
-import type { SourceFile } from "../rule.ts";
+import type { SourceFile } from "#rule.ts";
 import { FilesystemFailure, orWhenAbsent, readRequiredText } from "./filesystem.ts";
 import { posix } from "./ignore-scope.ts";
 import { scopeAbove, walk } from "./walk.ts";

package/src/manifests/sorted.ts

@@ -1,9 +1,9 @@
 import { basename, join, relative } from "node:path";
 import { Effect, FileSystem } from "effect";
 import { sortPackageJson } from "sort-package-json";
-import { FilesystemFailure } from "../inventory/filesystem.ts";
-import { posix } from "../inventory/ignore-scope.ts";
-import { walk } from "../inventory/walk.ts";
+import { FilesystemFailure } from "#inventory/filesystem.ts";
+import { posix } from "#inventory/ignore-scope.ts";
+import { walk } from "#inventory/walk.ts";
 
 export type Sorting = { readonly _tag: "Invalid" } | { readonly _tag: "Sorted" } | { readonly _tag: "Unsorted"; readonly sorted: string };
 

package/src/naming/exportFits.ts

@@ -0,0 +1,21 @@
+import { CAMEL, isUpper, PASCAL, sameWord, wordsOf } from "#naming/words.ts";
+
+function restIsFolders(rest: readonly string[], folders: readonly string[]): boolean {
+	const folderWords = folders.flatMap(wordsOf);
+	return rest.every((word) => folderWords.some((folder) => sameWord(word, folder)));
+}
+
+export function exportFits(name: string, stem: string, folders: readonly string[]): boolean {
+	if (!(CAMEL.test(stem) || PASCAL.test(stem)) || isUpper(stem) !== isUpper(name)) {
+		return false;
+	}
+	const named = wordsOf(name);
+	const filed = wordsOf(stem);
+	for (let start = 0; start + filed.length <= named.length; start += 1) {
+		const matches = filed.every((word, offset) => word === named[start + offset]);
+		if (matches && restIsFolders([...named.slice(0, start), ...named.slice(start + filed.length)], folders)) {
+			return true;
+		}
+	}
+	return false;
+}

package/src/naming/mainExport.ts

@@ -0,0 +1,11 @@
+import type { OwnExport } from "#naming/ownExports.ts";
+
+export function mainExport(exports: readonly OwnExport[]): OwnExport | undefined {
+	const values = exports.filter((entry) => entry.kind === "value");
+	const types = exports.filter((entry) => entry.kind === "type");
+	const [value] = values;
+	if (values.length === 1 && value !== undefined && types.every((type) => type.name.startsWith(value.name))) {
+		return value;
+	}
+	return values.length === 0 && types.length === 1 ? types[0] : undefined;
+}

package/src/naming/ownExports.ts

@@ -0,0 +1,95 @@
+import ts from "typescript";
+
+export interface OwnExport {
+	readonly constant: boolean;
+	readonly kind: "type" | "value";
+	readonly name: string;
+}
+
+const CONSTANT_CASE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/u;
+
+const PRIMITIVE_LITERALS: ReadonlySet<ts.SyntaxKind> = new Set([
+	ts.SyntaxKind.BigIntLiteral,
+	ts.SyntaxKind.FalseKeyword,
+	ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+	ts.SyntaxKind.NumericLiteral,
+	ts.SyntaxKind.StringLiteral,
+	ts.SyntaxKind.TrueKeyword,
+]);
+
+function isPrimitiveLiteral(node: ts.Expression | undefined): boolean {
+	if (node === undefined) {
+		return false;
+	}
+	if (ts.isPrefixUnaryExpression(node)) {
+		return isPrimitiveLiteral(node.operand);
+	}
+	return PRIMITIVE_LITERALS.has(node.kind);
+}
+
+function isExported(statement: ts.Statement): boolean {
+	const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+	const exported = modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+	const isDefault = modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+	return exported && !isDefault;
+}
+
+function variables(statement: ts.VariableStatement): readonly OwnExport[] {
+	const constant = (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+	return statement.declarationList.declarations.flatMap((declaration) =>
+		ts.isIdentifier(declaration.name)
+			? [
+					{
+						constant: constant && (CONSTANT_CASE.test(declaration.name.text) || isPrimitiveLiteral(declaration.initializer)),
+						kind: "value" as const,
+						name: declaration.name.text,
+					},
+				]
+			: [],
+	);
+}
+
+function declared(statement: ts.Statement): readonly OwnExport[] {
+	if (ts.isVariableStatement(statement)) {
+		return variables(statement);
+	}
+	if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+		return [{ constant: false, kind: "type", name: statement.name.text }];
+	}
+	const named =
+		ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)
+			? statement.name
+			: undefined;
+	return named !== undefined && ts.isIdentifier(named) ? [{ constant: false, kind: "value", name: named.text }] : [];
+}
+
+function locals(source: ts.SourceFile): ReadonlyMap<string, OwnExport> {
+	const all = source.statements.flatMap(declared);
+	return new Map(all.map((local) => [local.name, local]));
+}
+
+function listed(statement: ts.ExportDeclaration, known: ReadonlyMap<string, OwnExport>): readonly OwnExport[] {
+	const clause = statement.exportClause;
+	if (statement.moduleSpecifier !== undefined || clause === undefined || !ts.isNamedExports(clause)) {
+		return [];
+	}
+	return clause.elements.flatMap((element) => {
+		const name = element.name.text;
+		const local = known.get((element.propertyName ?? element.name).text);
+		if (name === "default" || local === undefined) {
+			return [];
+		}
+		const typeOnly = statement.isTypeOnly || element.isTypeOnly;
+		return [{ constant: local.constant, kind: typeOnly ? ("type" as const) : local.kind, name }];
+	});
+}
+
+export function ownExports(source: ts.SourceFile): readonly OwnExport[] {
+	const known = locals(source);
+	return source.statements.flatMap((statement) => {
+		if (ts.isExportDeclaration(statement)) {
+			return listed(statement, known);
+		}
+		return isExported(statement) ? declared(statement) : [];
+	});
+}