@filipebraida/adonis-function-points 0.7.0 → 0.8.0

package/build/{resolvers-DaU4uAqT.js → resolvers-DhJO-qvQ.js}

@@ -380,11 +380,26 @@ function classOfReceiver(receiver) {
 		return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 	}
 	if (receiver.isKind(SyntaxKind.Identifier)) {
-		const init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		let init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		while (init?.isKind(SyntaxKind.AwaitExpression) || init?.isKind(SyntaxKind.ParenthesizedExpression)) init = init.getExpression();
 		if (init?.isKind(SyntaxKind.NewExpression)) {
 			const target = init.getExpression();
 			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
 		}
+		/**
+		* `const svc = await app.container.make(IntakeService)`: the container hands
+		* back an instance of the class named — the same binding as `new`, written the
+		* way a controller writes it when the service has dependencies of its own. On a
+		* reviewed application this shape carried the write of `POST /gestao/atribuicao`
+		* and 31 more sites, and none was followed (plan 0.8 §B).
+		*/
+		if (init?.isKind(SyntaxKind.CallExpression)) {
+			const callee = init.getExpression();
+			if (callee.isKind(SyntaxKind.PropertyAccessExpression) && callee.getName() === "make" && callee.getExpression().isKind(SyntaxKind.PropertyAccessExpression) && callee.getExpression().asKind(SyntaxKind.PropertyAccessExpression).getName() === "container") {
+				const made = init.getArguments()[0];
+				return made?.isKind(SyntaxKind.Identifier) ? made.getText() : null;
+			}
+		}
 	}
 	return null;
 }

package/build/{runners-Dm7cWGa-.js → runners-BpBJsGMj.js}

@@ -1,6 +1,6 @@
 import { c as IncomparableSourcesError, d as DEFAULTS, f as defineConfig, i as measureStructure, n as parseSamples, o as FACTOR_PRESETS, r as measureConformance, s as IncomparableRulesetsError, t as calibrate, u as diffCounts } from "./calibration-DVIf8hcE.js";
-import { y as toPosix } from "./resolvers-DaU4uAqT.js";
-import { n as analyze } from "./pipeline-DO2301fV.js";
+import { y as toPosix } from "./resolvers-DhJO-qvQ.js";
+import { n as analyze } from "./pipeline-C6kHKB9-.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";

package/build/src/albrecht/counter.d.ts

@@ -40,13 +40,17 @@ export declare const RULESET = "afp";
  * Three in 1.6.0: an output's DETs are what the transaction DELIVERS (the render
  * props, the response payload, what a command prints) read back to their origin;
  * a function of the same file and a `.map(fn)` by reference are followed, so
- * FTRs move; and ace commands are transactions, with flags as input.
+ * FTRs move; and ace commands are transactions, with flags as input. One in
+ * 1.7.0, wide: a write binds to what the variable IS — a destructured named
+ * interface, a followed method's return, a relation off a row, a loop over rows,
+ * the guard's user, a service the container made — and a write nobody can type is
+ * an unresolved call instead of silence.
  *
  * Without the bump, a baseline saved by the previous version compares cleanly
  * against this one and bills the tool's own improvement as work done. The guard
  * exists for exactly that, and only this constant arms it.
  */
-export declare const RULESET_VERSION = "1.6.0";
+export declare const RULESET_VERSION = "1.7.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-DO2301fV.js";
-import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-Dm7cWGa-.js";
+import { t as CoverageTooLowError } from "../pipeline-C6kHKB9-.js";
+import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-BpBJsGMj.js";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/build/src/inventory/graph/call_graph.d.ts

@@ -97,6 +97,13 @@ export type Behavior = {
         opaqueFields: string[];
         stores: string[];
     };
+    /**
+     * Of the stores delivered raw to a page, the columns the page reads off them
+     * (plan 0.8 §D). A store absent here leaves whole; one in `unreadablePages` leaves
+     * whole because the page could not be read, and says why.
+     */
+    pageReads: Record<string, string[]>;
+    unreadablePages: Record<string, string>;
     trace: TraceStep[];
     /** bodies reached, for `fp:diff` */
     scope: ScopeEntry[];

package/build/src/inventory/graph/deliveries.d.ts

@@ -1,6 +1,7 @@
 import { Node } from 'ts-morph';
 import type { CallExpression, SourceFile } from 'ts-morph';
 import type { RelationMap, StoreSymbols } from '../detectors/lucid.js';
+import type { PageRef } from './pages.js';
 import type { HandlerRef } from '../../types.js';
 /**
  * What a transaction DELIVERS — counting-decisions §6, plan 0.7 §A′.
@@ -18,7 +19,11 @@ import type { HandlerRef } from '../../types.js';
  * body returns — the graph does that in `run()`, once the bodies are known; this
  * module only says WHAT was delivered and where it came from.
  */
-export type Delivery = 
+export type Delivery = DeliveredValue & {
+    /** the page or template this value was handed to, when it was a render — what the page shows of it is read there */
+    via?: PageRef;
+};
+type DeliveredValue = 
 /** a variable bound to a store: its columns leave */
 {
     kind: 'store';
@@ -86,3 +91,4 @@ export type BodyDeliveries = {
  * response method, and what a `return` hands back that is not one of those calls.
  */
 export declare function deliveriesIn(ctx: DeliveryContext): BodyDeliveries;
+export {};

package/build/src/inventory/graph/pages.d.ts

@@ -0,0 +1,44 @@
+import type { Project } from 'ts-morph';
+import type { RelationMap } from '../detectors/lucid.js';
+import type { CollectedDataStore } from '../sources/data_stores.js';
+/**
+ * What the page SHOWS of a store handed to it raw — plan 0.7 §B / 0.8 §D,
+ * counting-decisions §6.
+ *
+ * The delivery rule (§A′) says which store leaves; a transformer or a `.select()`
+ * says which columns. With neither, the store left whole — and the CPM defines an
+ * output's DETs by what the user sees. The page is TypeScript (`.tsx`) or Edge,
+ * and the same reader that opened the controller can open it: from the
+ * component's props to every member read off a row, one child component deep.
+ *
+ * Where it cannot read — a second level of components, a spread, a package's
+ * component, two files answering to one page name — the store leaves whole and
+ * the transaction is REPORTED with the reason. Overestimating in the open, never a
+ * floor: a floor would undercount what the user sees.
+ */
+export type PageRef = {
+    engine: 'inertia' | 'edge';
+    page: string;
+};
+/** a store handed raw to a page, at a key path of its props (`vagas.data`) */
+export type RawDelivery = PageRef & {
+    store: string;
+    path: string;
+};
+export type PageReading = {
+    /** store -> columns the page reads off its rows */
+    columns: Map<string, Set<string>>;
+    /** store -> why the page could not be read for it (the store then leaves whole) */
+    unreadable: Map<string, string>;
+    /** store -> members the page reads that are NOT its columns (`inventor.nomeCompleto`, computed on the way) */
+    unknownMembers: Map<string, Set<string>>;
+};
+export type PageEnvironment = {
+    root: string;
+    project: Project;
+    stores: Map<string, CollectedDataStore>;
+    relations: RelationMap;
+    /** the application's subpath imports (`#tecnologias/ui/components/x`), as the graph resolves them */
+    resolveSpecifier: (specifier: string) => string | null;
+};
+export declare function readPages(deliveries: RawDelivery[], env: PageEnvironment): PageReading;

package/build/src/inventory/resolvers/index.js

@@ -1,2 +1,2 @@
-import { i as resolveCall, n as ignoreCalls, r as isTechnicalWrite, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-DaU4uAqT.js";
+import { i as resolveCall, n as ignoreCalls, r as isTechnicalWrite, t as BUILTIN_CALL_RESOLVERS } from "../../../resolvers-DhJO-qvQ.js";
 export { BUILTIN_CALL_RESOLVERS, ignoreCalls, isTechnicalWrite, resolveCall };

package/build/src/pipeline.js

@@ -1,2 +1,2 @@
-import { n as analyze, t as CoverageTooLowError } from "../pipeline-DO2301fV.js";
+import { n as analyze, t as CoverageTooLowError } from "../pipeline-C6kHKB9-.js";
 export { CoverageTooLowError, analyze };

package/build/src/types.d.ts

@@ -144,6 +144,10 @@ export type HandlerBehavior = {
         opaqueFields: string[];
         stores: string[];
     };
+    /** of the stores delivered raw to a page, the columns the page reads off them (§6, plan 0.8 §D) */
+    pageReads?: Record<string, string[]>;
+    /** stores a page could not be read for, and why: they leave whole */
+    unreadablePages?: Record<string, string>;
     /**
      * How each store was read: rows whole, `.select()` columns, or one aggregate
      * scalar; by its own chain (`direct`) or preloaded through another store (`via`).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@filipebraida/adonis-function-points",
   "description": "Automated function point counting and code metrics for AdonisJS applications.",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "engines": {
     "node": ">=24.0.0"
   },