@shivaedev/quality 0.67.0 → 0.67.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (129) hide show
  1. package/CHANGELOG.md +7 -0
  2. package/README.md +5 -5
  3. package/biome/declarations.json +7 -1
  4. package/biome/preset.json +7 -1
  5. package/dist/adapters/buildEntryPaths.d.ts +3 -0
  6. package/dist/adapters/buildEntryPaths.d.ts.map +1 -0
  7. package/dist/adapters/buildEntryPaths.js +48 -0
  8. package/dist/adapters/buildEntryPaths.js.map +1 -0
  9. package/dist/adapters/buildEntryValue.d.ts +4 -0
  10. package/dist/adapters/buildEntryValue.d.ts.map +1 -0
  11. package/dist/adapters/buildEntryValue.js +47 -0
  12. package/dist/adapters/buildEntryValue.js.map +1 -0
  13. package/dist/adapters/bundlerEntries.d.ts +3 -0
  14. package/dist/adapters/bundlerEntries.d.ts.map +1 -0
  15. package/dist/adapters/bundlerEntries.js +49 -0
  16. package/dist/adapters/bundlerEntries.js.map +1 -0
  17. package/dist/adapters/callbackEscapes.d.ts +3 -0
  18. package/dist/adapters/callbackEscapes.d.ts.map +1 -0
  19. package/dist/adapters/callbackEscapes.js +24 -0
  20. package/dist/adapters/callbackEscapes.js.map +1 -0
  21. package/dist/adapters/composedContext.d.ts +3 -0
  22. package/dist/adapters/composedContext.d.ts.map +1 -0
  23. package/dist/adapters/composedContext.js +42 -0
  24. package/dist/adapters/composedContext.js.map +1 -0
  25. package/dist/adapters/containerDependency.d.ts +4 -0
  26. package/dist/adapters/containerDependency.d.ts.map +1 -0
  27. package/dist/adapters/containerDependency.js +28 -0
  28. package/dist/adapters/containerDependency.js.map +1 -0
  29. package/dist/adapters/contextCaptureFindings.d.ts.map +1 -1
  30. package/dist/adapters/contextCaptureFindings.js +3 -1
  31. package/dist/adapters/contextCaptureFindings.js.map +1 -1
  32. package/dist/adapters/foreignResources.d.ts +3 -0
  33. package/dist/adapters/foreignResources.d.ts.map +1 -0
  34. package/dist/adapters/foreignResources.js +80 -0
  35. package/dist/adapters/foreignResources.js.map +1 -0
  36. package/dist/adapters/frameworkCallback.d.ts +4 -0
  37. package/dist/adapters/frameworkCallback.d.ts.map +1 -0
  38. package/dist/adapters/frameworkCallback.js +92 -0
  39. package/dist/adapters/frameworkCallback.js.map +1 -0
  40. package/dist/adapters/frameworkOwner.d.ts +3 -0
  41. package/dist/adapters/frameworkOwner.d.ts.map +1 -0
  42. package/dist/adapters/frameworkOwner.js +35 -0
  43. package/dist/adapters/frameworkOwner.js.map +1 -0
  44. package/dist/adapters/importedCall.d.ts +6 -0
  45. package/dist/adapters/importedCall.d.ts.map +1 -0
  46. package/dist/adapters/importedCall.js +26 -0
  47. package/dist/adapters/importedCall.js.map +1 -0
  48. package/dist/adapters/isToolConfig.d.ts +2 -0
  49. package/dist/adapters/isToolConfig.d.ts.map +1 -0
  50. package/dist/adapters/isToolConfig.js +7 -0
  51. package/dist/adapters/isToolConfig.js.map +1 -0
  52. package/dist/adapters/knip/configuration.d.ts +1 -1
  53. package/dist/adapters/knip/configuration.d.ts.map +1 -1
  54. package/dist/adapters/knip/configuration.js +3 -2
  55. package/dist/adapters/knip/configuration.js.map +1 -1
  56. package/dist/adapters/knip/run.d.ts.map +1 -1
  57. package/dist/adapters/knip/run.js +3 -1
  58. package/dist/adapters/knip/run.js.map +1 -1
  59. package/dist/adapters/localFunctions.d.ts +3 -0
  60. package/dist/adapters/localFunctions.d.ts.map +1 -0
  61. package/dist/adapters/localFunctions.js +20 -0
  62. package/dist/adapters/localFunctions.js.map +1 -0
  63. package/dist/adapters/reachableBuildEntries.d.ts +5 -0
  64. package/dist/adapters/reachableBuildEntries.d.ts.map +1 -0
  65. package/dist/adapters/reachableBuildEntries.js +52 -0
  66. package/dist/adapters/reachableBuildEntries.js.map +1 -0
  67. package/dist/adapters/serviceStateProblems.d.ts.map +1 -1
  68. package/dist/adapters/serviceStateProblems.js +26 -14
  69. package/dist/adapters/serviceStateProblems.js.map +1 -1
  70. package/dist/inventory/programmaticEntries.d.ts +4 -0
  71. package/dist/inventory/programmaticEntries.d.ts.map +1 -0
  72. package/dist/inventory/programmaticEntries.js +9 -0
  73. package/dist/inventory/programmaticEntries.js.map +1 -0
  74. package/dist/rules/effect/contextCapture.js +1 -1
  75. package/dist/rules/effect/contextCapture.js.map +1 -1
  76. package/dist/rules/effect/program.d.ts +1 -0
  77. package/dist/rules/effect/program.d.ts.map +1 -1
  78. package/dist/rules/effect/program.js +17 -1
  79. package/dist/rules/effect/program.js.map +1 -1
  80. package/dist/rules/effect/serviceCatalog.d.ts.map +1 -1
  81. package/dist/rules/effect/serviceCatalog.js +10 -2
  82. package/dist/rules/effect/serviceCatalog.js.map +1 -1
  83. package/dist/rules/effect/serviceFindings.d.ts.map +1 -1
  84. package/dist/rules/effect/serviceFindings.js +33 -7
  85. package/dist/rules/effect/serviceFindings.js.map +1 -1
  86. package/dist/rules/effect/serviceOrigin.d.ts.map +1 -1
  87. package/dist/rules/effect/serviceOrigin.js +13 -1
  88. package/dist/rules/effect/serviceOrigin.js.map +1 -1
  89. package/dist/rules/effect/serviceParameters.d.ts.map +1 -1
  90. package/dist/rules/effect/serviceParameters.js +12 -12
  91. package/dist/rules/effect/serviceParameters.js.map +1 -1
  92. package/dist/rules/effect/serviceTypes.d.ts.map +1 -1
  93. package/dist/rules/effect/serviceTypes.js +5 -1
  94. package/dist/rules/effect/serviceTypes.js.map +1 -1
  95. package/dist/rules/files/namedAfterExport.d.ts.map +1 -1
  96. package/dist/rules/files/namedAfterExport.js +14 -13
  97. package/dist/rules/files/namedAfterExport.js.map +1 -1
  98. package/package.json +2 -1
  99. package/src/adapters/buildEntryPaths.ts +52 -0
  100. package/src/adapters/buildEntryValue.ts +52 -0
  101. package/src/adapters/bundlerEntries.ts +53 -0
  102. package/src/adapters/callbackEscapes.ts +32 -0
  103. package/src/adapters/composedContext.ts +48 -0
  104. package/src/adapters/containerDependency.ts +40 -0
  105. package/src/adapters/contextCaptureFindings.ts +3 -1
  106. package/src/adapters/foreignResources.ts +83 -0
  107. package/src/adapters/frameworkCallback.ts +106 -0
  108. package/src/adapters/frameworkOwner.ts +41 -0
  109. package/src/adapters/importedCall.ts +27 -0
  110. package/src/adapters/isToolConfig.ts +10 -0
  111. package/src/adapters/knip/configuration.ts +3 -2
  112. package/src/adapters/knip/run.ts +3 -1
  113. package/src/adapters/localFunctions.ts +22 -0
  114. package/src/adapters/reachableBuildEntries.ts +58 -0
  115. package/src/adapters/serviceStateProblems.ts +42 -17
  116. package/src/inventory/programmaticEntries.ts +10 -0
  117. package/src/rules/effect/contextCapture.ts +1 -1
  118. package/src/rules/effect/program.ts +19 -1
  119. package/src/rules/effect/serviceCatalog.ts +12 -2
  120. package/src/rules/effect/serviceFindings.ts +38 -7
  121. package/src/rules/effect/serviceOrigin.ts +14 -1
  122. package/src/rules/effect/serviceParameters.ts +13 -14
  123. package/src/rules/effect/serviceTypes.ts +11 -1
  124. package/src/rules/files/namedAfterExport.ts +19 -13
  125. package/dist/adapters/initializerDependency.d.ts +0 -3
  126. package/dist/adapters/initializerDependency.d.ts.map +0 -1
  127. package/dist/adapters/initializerDependency.js +0 -53
  128. package/dist/adapters/initializerDependency.js.map +0 -1
  129. package/src/adapters/initializerDependency.ts +0 -57
@@ -0,0 +1,53 @@
1
+ import { posix } from "node:path";
2
+ import ts from "typescript";
3
+ import type { SourceFile } from "#rule.ts";
4
+ import { parse } from "#rules/parse.ts";
5
+ import { buildEntryPaths } from "./buildEntryPaths.ts";
6
+ import { buildEntryValue, buildOption } from "./buildEntryValue.ts";
7
+ import { importedCall } from "./importedCall.ts";
8
+
9
+ const ESBUILD = new Set(["build", "buildSync", "context"]);
10
+
11
+ function entryOption(call: ts.CallExpression): string | undefined {
12
+ const expression = call.expression;
13
+ if (ts.isPropertyAccessExpression(expression) && expression.expression.getText() === "Bun" && expression.name.text === "build") {
14
+ return "entrypoints";
15
+ }
16
+ const imported = importedCall(call);
17
+ return imported?.module === "esbuild" && ESBUILD.has(imported.name) ? "entryPoints" : undefined;
18
+ }
19
+
20
+ function entriesOf(call: ts.CallExpression, file: string, cwd: string): readonly string[] {
21
+ const option = entryOption(call);
22
+ const [argument] = call.arguments;
23
+ const options = argument === undefined ? undefined : buildEntryValue(argument);
24
+ if (option === undefined || options === undefined || !ts.isObjectLiteralExpression(options)) {
25
+ return [];
26
+ }
27
+ const directory = buildOption(options, "absWorkingDir");
28
+ const working = directory === undefined ? cwd : buildEntryPaths(directory, cwd, file)[0];
29
+ if (working === undefined) {
30
+ return [];
31
+ }
32
+ const entries = buildOption(options, option);
33
+ return entries === undefined ? [] : buildEntryPaths(entries, cwd, file).map((path) => posix.resolve(cwd, working, path));
34
+ }
35
+
36
+ export function bundlerEntries(file: SourceFile, root: string, directory: string): readonly string[] {
37
+ if (!(file.text.includes("esbuild") || file.text.includes("Bun"))) {
38
+ return [];
39
+ }
40
+ const source = parse(file);
41
+ if (source === undefined) {
42
+ return [];
43
+ }
44
+ const entries: string[] = [];
45
+ function visit(node: ts.Node): void {
46
+ if (ts.isCallExpression(node)) {
47
+ entries.push(...entriesOf(node, posix.join(root, file.path), posix.join(root, directory)).map((path) => posix.relative(root, path)));
48
+ }
49
+ ts.forEachChild(node, visit);
50
+ }
51
+ visit(source);
52
+ return entries;
53
+ }
@@ -0,0 +1,32 @@
1
+ import type ts from "typescript";
2
+
3
+ export function callbackEscapes(checker: ts.TypeChecker, call: ts.CallExpression, callback: ts.Node): boolean {
4
+ const seen = new Set<ts.Type>();
5
+ function exposed(type: ts.Type): boolean {
6
+ if (seen.has(type) || ["~effect/Effect", "~effect/Stream", "~effect/Layer"].some((brand) => type.getProperty(brand) !== undefined)) {
7
+ return false;
8
+ }
9
+ seen.add(type);
10
+ if (type.isUnionOrIntersection()) {
11
+ return type.types.some(exposed);
12
+ }
13
+ if (
14
+ type
15
+ .getCallSignatures()
16
+ .some((signature) => signature.parameters.some((parameter) => parameter.declarations?.some((declaration) => declaration.parent === callback)))
17
+ ) {
18
+ return true;
19
+ }
20
+ return (
21
+ checker.getIndexInfosOfType(type).some((index) => exposed(index.type))
22
+ || type
23
+ .getProperties()
24
+ .some(
25
+ (property) =>
26
+ (property.declarations ?? []).some((declaration) => declaration.getSourceFile() === callback.getSourceFile())
27
+ && exposed(checker.getTypeOfSymbol(property)),
28
+ )
29
+ );
30
+ }
31
+ return exposed(checker.getTypeAtLocation(call));
32
+ }
@@ -0,0 +1,48 @@
1
+ import ts from "typescript";
2
+ import { effectApi, resolvedValue } from "#adapters/serviceModelSyntax.ts";
3
+ import { boundaryReference } from "#rules/effect/boundaryReference.ts";
4
+
5
+ function closedEffect(checker: ts.TypeChecker, node: ts.Node): boolean {
6
+ const brand = checker.getTypeAtLocation(node).getProperty("~effect/Effect");
7
+ const requirement = brand === undefined ? undefined : checker.getTypeOfSymbol(brand).getProperty("_R");
8
+ const type = requirement === undefined ? undefined : checker.getTypeOfSymbol(requirement).getCallSignatures()[0]?.getReturnType();
9
+ return type !== undefined && (type.flags & ts.TypeFlags.Never) !== 0;
10
+ }
11
+
12
+ function layerProvision(checker: ts.TypeChecker, node: ts.Node): boolean {
13
+ return (
14
+ ts.isCallExpression(node)
15
+ && effectApi(checker, node.expression, "provide")
16
+ && node.arguments.some((argument) => checker.getTypeAtLocation(argument).getProperty("~effect/Layer") !== undefined)
17
+ );
18
+ }
19
+
20
+ export function composedContext(checker: ts.TypeChecker, environment: ts.Expression): boolean {
21
+ const value = resolvedValue(checker, environment);
22
+ if (!(ts.isYieldExpression(value) && value.expression !== undefined && ts.isCallExpression(value.expression))) {
23
+ return false;
24
+ }
25
+ const acquisition = value.expression;
26
+ const reference = boundaryReference(checker, acquisition.expression);
27
+ if (
28
+ reference === "effect.Layer.build"
29
+ || reference === "effect/Layer.build"
30
+ || reference === "effect.Layer.buildWithScope"
31
+ || reference === "effect/Layer.buildWithScope"
32
+ ) {
33
+ return true;
34
+ }
35
+ if (!effectApi(checker, acquisition.expression, "context")) {
36
+ return false;
37
+ }
38
+ let provided = false;
39
+ for (let ancestor: ts.Node | undefined = value.parent; ancestor !== undefined; ancestor = ancestor.parent) {
40
+ if (ts.isCallExpression(ancestor)) {
41
+ provided ||= layerProvision(checker, ancestor) || ancestor.arguments.some((argument) => layerProvision(checker, argument));
42
+ if (provided && closedEffect(checker, ancestor)) {
43
+ return true;
44
+ }
45
+ }
46
+ }
47
+ return false;
48
+ }
@@ -0,0 +1,40 @@
1
+ import ts from "typescript";
2
+ import type { serviceTypes } from "#rules/effect/serviceTypes.ts";
3
+
4
+ const NATIVE =
5
+ /\/effect\/(?:src|dist(?:\/dts)?)\/(?:Ref|SynchronizedRef|ScopedRef|Cache|ScopedCache|Deferred|Queue|PubSub|HashMap|HashSet)\.(?:d\.)?ts$/u;
6
+ const COLLECTIONS = new Set(["Map", "ReadonlyMap", "Set", "ReadonlySet", "Array", "ReadonlyArray"]);
7
+
8
+ function reference(type: ts.Type): type is ts.TypeReference {
9
+ return "objectFlags" in type && typeof type.objectFlags === "number" && (type.objectFlags & ts.ObjectFlags.Reference) !== 0;
10
+ }
11
+
12
+ function container(type: ts.Type): boolean {
13
+ const symbol = type.getSymbol();
14
+ return (symbol?.declarations ?? []).some((declaration) => {
15
+ const file = declaration.getSourceFile().fileName.replaceAll("\\", "/");
16
+ return NATIVE.test(file) || (COLLECTIONS.has(symbol?.name ?? "") && /\/lib\.[^/]+\.d\.ts$/u.test(file));
17
+ });
18
+ }
19
+
20
+ export function containerDependency(
21
+ checker: ts.TypeChecker,
22
+ type: ts.Type,
23
+ services: ReturnType<typeof serviceTypes>,
24
+ seen = new Set<ts.Type>(),
25
+ ): boolean {
26
+ if (seen.has(type) || !(type.flags & (ts.TypeFlags.Object | ts.TypeFlags.Union | ts.TypeFlags.Intersection)) || services.computation(type)) {
27
+ return false;
28
+ }
29
+ seen.add(type);
30
+ if (type.isUnionOrIntersection()) {
31
+ return type.types.some((part) => containerDependency(checker, part, services, seen));
32
+ }
33
+ if (container(type) && reference(type)) {
34
+ return checker.getTypeArguments(type).some((argument) => services.carries(argument) || containerDependency(checker, argument, services, seen));
35
+ }
36
+ return (
37
+ type.getCallSignatures().length === 0
38
+ && type.getProperties().some((property) => containerDependency(checker, checker.getTypeOfSymbol(property), services, seen))
39
+ );
40
+ }
@@ -1,6 +1,7 @@
1
1
  import { join } from "node:path";
2
2
  import { Effect } from "effect";
3
3
  import ts from "typescript";
4
+ import { composedContext } from "#adapters/composedContext.ts";
4
5
  import { effectApi } from "#adapters/serviceModelSyntax.ts";
5
6
  import type { Finding, RuleInputs } from "#rule.ts";
6
7
  import { effectProgram } from "#rules/effect/program.ts";
@@ -41,7 +42,8 @@ export const contextCaptureFindings = Effect.fn("ContextCapture.contextCaptureFi
41
42
  const syntax = source;
42
43
  const findings: Finding[] = [];
43
44
  function visit(node: ts.Node): void {
44
- if (ts.isCallExpression(node) && reprovides(checker, node)) {
45
+ const environment = ts.isCallExpression(node) ? node.arguments.at(-1) : undefined;
46
+ if (ts.isCallExpression(node) && reprovides(checker, node) && !(environment !== undefined && composedContext(checker, environment))) {
45
47
  findings.push({
46
48
  file: file.path,
47
49
  line: syntax.getLineAndCharacterOfPosition(node.getStart(syntax)).line + 1,
@@ -0,0 +1,83 @@
1
+ import ts from "typescript";
2
+ import { serviceProperty } from "#adapters/serviceAssemblySyntax.ts";
3
+ import { effectApi, resolvedValue } from "#adapters/serviceModelSyntax.ts";
4
+ import { returnValues } from "#rules/stories/returnValues.ts";
5
+
6
+ function foreign(node: ts.Declaration): boolean {
7
+ const file = node.getSourceFile().fileName.replaceAll("\\", "/");
8
+ return file.includes("/node_modules/") && !/\/(?:effect|@effect|@shivaedev)\//u.test(file);
9
+ }
10
+
11
+ function constructed(checker: ts.TypeChecker, node: ts.Node, seen = new Set<ts.Node>()): boolean {
12
+ if (seen.has(node)) {
13
+ return false;
14
+ }
15
+ seen.add(node);
16
+ if (ts.isExpression(node)) {
17
+ const value = resolvedValue(checker, node);
18
+ if (value !== node) {
19
+ return constructed(checker, value, seen);
20
+ }
21
+ }
22
+ if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
23
+ return acquisition(checker, node, seen);
24
+ }
25
+ if (ts.isYieldExpression(node)) {
26
+ return node.expression === undefined ? false : constructed(checker, node.expression, seen);
27
+ }
28
+ return ts.isFunctionLike(node) && returnValues(node).some((value) => value !== undefined && constructed(checker, value, seen));
29
+ }
30
+
31
+ function acquisition(checker: ts.TypeChecker, node: ts.CallExpression | ts.NewExpression, seen: Set<ts.Node>): boolean {
32
+ const signature = checker.getResolvedSignature(node);
33
+ if (signature?.declaration !== undefined && foreign(signature.declaration)) {
34
+ return true;
35
+ }
36
+ if (!(ts.isCallExpression(node) && ["promise", "tryPromise", "sync", "acquireRelease"].some((name) => effectApi(checker, node.expression, name)))) {
37
+ return false;
38
+ }
39
+ const value = node.arguments[0];
40
+ const callback = value !== undefined && ts.isObjectLiteralExpression(value) ? serviceProperty(value, "try") : value;
41
+ return callback !== undefined && constructed(checker, callback, seen);
42
+ }
43
+
44
+ export function foreignResources(checker: ts.TypeChecker, sources: readonly ts.SourceFile[]) {
45
+ let calls: Map<ts.ParameterDeclaration, ts.Expression[]> | undefined;
46
+ function argumentsIn() {
47
+ if (calls !== undefined) {
48
+ return calls;
49
+ }
50
+ const arguments_ = new Map<ts.ParameterDeclaration, ts.Expression[]>();
51
+ function visit(node: ts.Node): void {
52
+ if (ts.isCallExpression(node)) {
53
+ const declaration = checker.getResolvedSignature(node)?.declaration;
54
+ for (const [index, parameter] of (declaration?.parameters ?? []).entries()) {
55
+ const argument = node.arguments[index];
56
+ if (argument !== undefined && ts.isParameter(parameter)) {
57
+ const values = arguments_.get(parameter) ?? [];
58
+ values.push(argument);
59
+ arguments_.set(parameter, values);
60
+ }
61
+ }
62
+ }
63
+ ts.forEachChild(node, visit);
64
+ }
65
+ for (const source of sources) {
66
+ visit(source);
67
+ }
68
+ calls = arguments_;
69
+ return arguments_;
70
+ }
71
+ return (parameter: ts.ParameterDeclaration): boolean => {
72
+ const source = parameter.getSourceFile();
73
+ if (!/(?:^|\/)adapters\//u.test(source.fileName)) {
74
+ return false;
75
+ }
76
+ const type = checker.getTypeAtLocation(parameter);
77
+ if (!(type.getSymbol()?.declarations ?? []).some(foreign) || type.getProperty("~effect/Context/Service") !== undefined) {
78
+ return false;
79
+ }
80
+ const values = argumentsIn().get(parameter) ?? [];
81
+ return values.length > 0 && values.every((value) => constructed(checker, value));
82
+ };
83
+ }
@@ -0,0 +1,106 @@
1
+ import ts from "typescript";
2
+ import { callbackEscapes } from "#adapters/callbackEscapes.ts";
3
+ import { frameworkOwner } from "#adapters/frameworkOwner.ts";
4
+ import { effectApi, resolvedValue } from "#adapters/serviceModelSyntax.ts";
5
+
6
+ function supplied(signature: ts.Signature, local: ReadonlySet<ts.SourceFile>): boolean {
7
+ return signature.declaration !== undefined && !local.has(signature.declaration.getSourceFile());
8
+ }
9
+
10
+ function wrapsEffectFunction(checker: ts.TypeChecker, expression: ts.Expression): boolean {
11
+ let callee = expression;
12
+ let value: ts.Node = ts.isIdentifier(callee) ? resolvedValue(checker, callee) : callee;
13
+ while (ts.isCallExpression(value)) {
14
+ if (value.arguments.some((argument) => checker.getTypeAtLocation(argument).getCallSignatures().length > 0)) {
15
+ return false;
16
+ }
17
+ callee = value.expression;
18
+ value = ts.isIdentifier(callee) ? resolvedValue(checker, callee) : callee;
19
+ }
20
+ return effectApi(checker, callee, "fn") || effectApi(checker, callee, "fnUntraced");
21
+ }
22
+
23
+ export function frameworkCallback(checker: ts.TypeChecker, node: ts.Node, local: ReadonlySet<ts.SourceFile>, seen = new Set<ts.Node>()): boolean {
24
+ if (seen.has(node)) {
25
+ return false;
26
+ }
27
+ seen.add(node);
28
+ if (!(ts.isArrowFunction(node) || ts.isFunctionExpression(node))) {
29
+ return false;
30
+ }
31
+ if (ts.isCallExpression(node.parent)) {
32
+ if (wrapsEffectFunction(checker, node.parent.expression)) {
33
+ return false;
34
+ }
35
+ if (frameworkOwner(checker, node.parent.expression, local, (owner) => frameworkCallback(checker, owner, local, seen))) {
36
+ const parent = node.parent.parent;
37
+ return !(
38
+ (ts.isVariableDeclaration(parent)
39
+ || ts.isReturnStatement(parent)
40
+ || ts.isPropertyAssignment(parent)
41
+ || (ts.isCallExpression(parent) && parent.expression === node.parent))
42
+ && callbackEscapes(checker, node.parent, node)
43
+ );
44
+ }
45
+ return !callbackEscapes(checker, node.parent, node);
46
+ }
47
+ const contextual = checker.getContextualType(node);
48
+ if ((contextual === undefined ? [] : checker.getNonNullableType(contextual).getCallSignatures()).some((signature) => supplied(signature, local))) {
49
+ return true;
50
+ }
51
+ const property = node.parent;
52
+ const object = property.parent;
53
+ const call = object.parent;
54
+ return (
55
+ ts.isPropertyAssignment(property)
56
+ && ts.isObjectLiteralExpression(object)
57
+ && ts.isCallExpression(call)
58
+ && checker
59
+ .getTypeAtLocation(call.expression)
60
+ .getCallSignatures()
61
+ .some((signature) => supplied(signature, local))
62
+ );
63
+ }
64
+
65
+ function overloadedParameter(checker: ts.TypeChecker, parameter: ts.ParameterDeclaration): ts.ParameterDeclaration | undefined {
66
+ const fn = parameter.parent;
67
+ if ((ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) && fn.name !== undefined) {
68
+ const symbol = checker.getSymbolAtLocation(fn.name);
69
+ const signature = symbol?.declarations?.find(
70
+ (declaration) => (ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration)) && declaration.body === undefined,
71
+ );
72
+ if (signature !== undefined && (ts.isFunctionDeclaration(signature) || ts.isMethodDeclaration(signature))) {
73
+ return signature.parameters[fn.parameters.indexOf(parameter)];
74
+ }
75
+ }
76
+ return undefined;
77
+ }
78
+
79
+ export function parameterSite(
80
+ checker: ts.TypeChecker,
81
+ parameter: ts.ParameterDeclaration,
82
+ local: ReadonlySet<ts.SourceFile>,
83
+ ): ts.ParameterDeclaration {
84
+ const fn = parameter.parent;
85
+ const overload = overloadedParameter(checker, parameter);
86
+ if (overload !== undefined) {
87
+ return overload;
88
+ }
89
+ if (!(ts.isArrowFunction(fn) || ts.isFunctionExpression(fn))) {
90
+ return parameter;
91
+ }
92
+ const contextual = checker.getContextualType(fn);
93
+ const signature = contextual === undefined ? undefined : checker.getNonNullableType(contextual).getCallSignatures()[0];
94
+ const declared = signature?.declaration;
95
+ if (declared !== undefined && declared !== fn && local.has(declared.getSourceFile())) {
96
+ const site = declared.parameters[fn.parameters.indexOf(parameter)];
97
+ if (site !== undefined && ts.isParameter(site)) {
98
+ return site;
99
+ }
100
+ }
101
+ const variable = fn.parent;
102
+ if (!(ts.isVariableDeclaration(variable) && variable.type !== undefined && ts.isFunctionTypeNode(variable.type))) {
103
+ return parameter;
104
+ }
105
+ return variable.type.parameters[fn.parameters.indexOf(parameter)] ?? parameter;
106
+ }
@@ -0,0 +1,41 @@
1
+ import ts from "typescript";
2
+
3
+ export function frameworkOwner(
4
+ checker: ts.TypeChecker,
5
+ node: ts.Node,
6
+ local: ReadonlySet<ts.SourceFile>,
7
+ callback: (node: ts.Node) => boolean,
8
+ seen = new Set<ts.Node>(),
9
+ ): boolean {
10
+ if (seen.has(node)) {
11
+ return false;
12
+ }
13
+ seen.add(node);
14
+ if (ts.isArrayLiteralExpression(node)) {
15
+ return true;
16
+ }
17
+ if (ts.isYieldExpression(node)) {
18
+ return node.expression !== undefined && frameworkOwner(checker, node.expression, local, callback, seen);
19
+ }
20
+ if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node) || ts.isCallExpression(node) || ts.isParenthesizedExpression(node)) {
21
+ return frameworkOwner(checker, node.expression, local, callback, seen);
22
+ }
23
+ if (!ts.isIdentifier(node)) {
24
+ return false;
25
+ }
26
+ const symbol = checker.getSymbolAtLocation(node);
27
+ const target = symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
28
+ return (target?.declarations ?? []).some((declaration) => {
29
+ if (!local.has(declaration.getSourceFile())) {
30
+ return true;
31
+ }
32
+ if (ts.isVariableDeclaration(declaration) && declaration.initializer !== undefined) {
33
+ return frameworkOwner(checker, declaration.initializer, local, callback, seen);
34
+ }
35
+ let parameter: ts.Node = declaration;
36
+ while (ts.isBindingElement(parameter) || ts.isObjectBindingPattern(parameter) || ts.isArrayBindingPattern(parameter)) {
37
+ parameter = parameter.parent;
38
+ }
39
+ return ts.isParameter(parameter) && callback(parameter.parent);
40
+ });
41
+ }
@@ -0,0 +1,27 @@
1
+ import ts from "typescript";
2
+
3
+ function calledName(expression: ts.LeftHandSideExpression, clause: ts.ImportClause): string | undefined {
4
+ const bindings = clause.namedBindings;
5
+ if (ts.isIdentifier(expression) && bindings !== undefined && ts.isNamedImports(bindings)) {
6
+ const imported = bindings.elements.find((element) => element.name.text === expression.text);
7
+ return imported === undefined ? undefined : (imported.propertyName ?? imported.name).text;
8
+ }
9
+ if (!(ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression))) {
10
+ return undefined;
11
+ }
12
+ const namespace = bindings !== undefined && ts.isNamespaceImport(bindings) ? bindings.name.text : clause.name?.text;
13
+ return namespace === expression.expression.text ? expression.name.text : undefined;
14
+ }
15
+
16
+ export function importedCall(call: ts.CallExpression): { readonly module: string; readonly name: string } | undefined {
17
+ for (const statement of call.getSourceFile().statements) {
18
+ if (!(ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) || statement.importClause === undefined) {
19
+ continue;
20
+ }
21
+ const name = calledName(call.expression, statement.importClause);
22
+ if (name !== undefined) {
23
+ return { module: statement.moduleSpecifier.text, name };
24
+ }
25
+ }
26
+ return undefined;
27
+ }
@@ -0,0 +1,10 @@
1
+ import { posix } from "node:path";
2
+ import preset from "#biome-preset" with { type: "json" };
3
+
4
+ const PATTERNS = preset.overrides.flatMap((override) =>
5
+ override.includes.includes("**/*.config.*") && override.linter?.rules?.style?.noDefaultExport === "off" ? override.includes : [],
6
+ );
7
+
8
+ export function isToolConfig(path: string): boolean {
9
+ return PATTERNS.some((pattern) => posix.matchesGlob(path, pattern));
10
+ }
@@ -26,7 +26,7 @@ function importPaths(imports: Readonly<Record<string, unknown>>) {
26
26
  );
27
27
  }
28
28
 
29
- export async function knipConfiguration(inputs: RuleInputs, toolOwned: readonly string[] = []) {
29
+ export async function knipConfiguration(inputs: RuleInputs, toolOwned: readonly string[] = [], programmatic: ReadonlySet<string> = new Set()) {
30
30
  const packages = await workspacePackages(inputs);
31
31
  const manifests = await Promise.all(
32
32
  [".", ...packages.map(({ directory }) => directory)].map(async (directory) => {
@@ -40,6 +40,7 @@ export async function knipConfiguration(inputs: RuleInputs, toolOwned: readonly
40
40
  .filter(({ path }) => (packageOf(packages, path)?.directory ?? ".") === directory)
41
41
  .map(({ path }) => posix.relative(directory, path));
42
42
  const scriptEntries = sources.filter((path) => scripted.has(posix.join(directory, path)));
43
+ const bundled = sources.filter((path) => programmatic.has(posix.join(directory, path)));
43
44
  const bins = exportTargets(manifest.bin).map((target) => target.replace(/^\.\//u, ""));
44
45
  const binaries = sources.filter(
45
46
  (path) => bins.includes(path) || bins.includes(path.replace(/^src\//u, "dist/").replace(/\.(?<mode>[cm]?)tsx?$/u, ".$<mode>js")),
@@ -56,7 +57,7 @@ export async function knipConfiguration(inputs: RuleInputs, toolOwned: readonly
56
57
  return [
57
58
  directory,
58
59
  {
59
- entry: [...ENTRIES, ...publicFiles, ...migrations, ...bins, ...binaries, ...scriptEntries, ...ui, ...styles],
60
+ entry: [...ENTRIES, ...publicFiles, ...migrations, ...bins, ...binaries, ...scriptEntries, ...bundled, ...ui, ...styles],
60
61
  paths: importPaths(manifest.imports ?? {}),
61
62
  project: [...sources, ...ui, ...styles],
62
63
  vitest: { config: ["vitest*.config.{ts,mts,cts,js,mjs,cjs}", "vitest.{workspace,projects}.{ts,mts,cts,js,mjs,cjs,json}"] },
@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
5
5
  import { Effect, FileSystem, Stream } from "effect";
6
6
  import { ChildProcess, ChildProcessSpawner } from "effect/process";
7
7
  import { readPackageManifest } from "#adapters/manifestInventory.ts";
8
+ import { programmaticEntries } from "#inventory/programmaticEntries.ts";
8
9
  import { shadcnFolders } from "#inventory/shadcnFolders.ts";
9
10
  import type { RuleInputs } from "#rule.ts";
10
11
  import { knipConfiguration } from "./configuration.ts";
@@ -26,7 +27,8 @@ export const runKnip = Effect.fn("Knip.runKnip")(function* (inputs: RuleInputs)
26
27
  return [];
27
28
  }
28
29
  const folders = yield* shadcnFolders(inputs.root);
29
- const configuration = yield* Effect.promise(() => knipConfiguration(inputs, folders));
30
+ const entries = yield* programmaticEntries(inputs);
31
+ const configuration = yield* Effect.promise(() => knipConfiguration(inputs, folders, entries));
30
32
  const checked = new Set([...inputs.files, ...Object.keys(configuration.workspaces).map((directory) => posix.join(directory, "package.json"))]);
31
33
  const findings = yield* Effect.scoped(
32
34
  Effect.gen(function* () {
@@ -0,0 +1,22 @@
1
+ import ts from "typescript";
2
+ import { frameworkCallback } from "#adapters/frameworkCallback.ts";
3
+
4
+ export function localFunctions(sources: readonly ts.SourceFile[], checker: ts.TypeChecker, parameters: (signature: ts.Signature) => void): void {
5
+ const local = new Set(sources);
6
+ function visit(node: ts.Node): void {
7
+ if (
8
+ (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node))
9
+ && node.parameters.length > 0
10
+ && !frameworkCallback(checker, node, local)
11
+ ) {
12
+ const signature = checker.getSignatureFromDeclaration(node);
13
+ if (signature !== undefined) {
14
+ parameters(signature);
15
+ }
16
+ }
17
+ ts.forEachChild(node, visit);
18
+ }
19
+ for (const source of sources) {
20
+ visit(source);
21
+ }
22
+ }
@@ -0,0 +1,58 @@
1
+ import type { ImportGraph } from "#imports/graph.ts";
2
+ import type { PackageLayout } from "#naming/packageLayout.ts";
3
+ import type { RuleInputs } from "#rule.ts";
4
+ import { bundlerEntries } from "./bundlerEntries.ts";
5
+
6
+ function scriptsByPackage(layout: PackageLayout): ReadonlyMap<string, readonly string[]> {
7
+ const scripts = new Map<string, string[]>();
8
+ for (const script of layout.scripts) {
9
+ const roots = [...layout.names.keys()].filter((folder) => folder === "" || script.startsWith(`${folder}/`));
10
+ const directory = roots.toSorted((left, right) => right.length - left.length)[0] ?? "";
11
+ scripts.set(directory, [...(scripts.get(directory) ?? []), script]);
12
+ }
13
+ return scripts;
14
+ }
15
+
16
+ function reachable(roots: readonly string[], imports: ReadonlyMap<string, readonly string[]>): ReadonlySet<string> {
17
+ const visited = new Set<string>();
18
+ const pending = [...roots];
19
+ while (pending.length > 0) {
20
+ const path = pending.pop();
21
+ if (path === undefined || visited.has(path)) {
22
+ continue;
23
+ }
24
+ visited.add(path);
25
+ pending.push(...(imports.get(path) ?? []));
26
+ }
27
+ return visited;
28
+ }
29
+
30
+ function importsOf(graph: ImportGraph): ReadonlyMap<string, readonly string[]> {
31
+ const imports = new Map<string, string[]>();
32
+ for (const edge of graph.edges) {
33
+ if (!edge.type && edge.to.kind === "file") {
34
+ imports.set(edge.from, [...(imports.get(edge.from) ?? []), edge.to.path]);
35
+ }
36
+ }
37
+ return imports;
38
+ }
39
+
40
+ export function reachableBuildEntries(inputs: RuleInputs, graph: ImportGraph, layout: PackageLayout): ReadonlySet<string> {
41
+ const imports = importsOf(graph);
42
+ const sources = new Map(inputs.sources.map((source) => [source.path, source]));
43
+ const entries = new Set<string>();
44
+ for (const [directory, scripts] of scriptsByPackage(layout)) {
45
+ for (const path of reachable(scripts, imports)) {
46
+ const source = sources.get(path);
47
+ if (source === undefined) {
48
+ continue;
49
+ }
50
+ for (const entry of bundlerEntries(source, inputs.root, directory)) {
51
+ if (sources.has(entry)) {
52
+ entries.add(entry);
53
+ }
54
+ }
55
+ }
56
+ }
57
+ return entries;
58
+ }