@filipebraida/adonis-function-points 0.1.0 → 0.3.0

package/build/commands/fp_metrics.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+export default class FpMetrics extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    out?: string;
+    json?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/main.d.ts

@@ -1,5 +1,6 @@
-export { default as FpInventory } from './fp_inventory.js';
-export { default as FpCount } from './fp_count.js';
-export { default as FpExplain } from './fp_explain.js';
-export { default as FpDiff } from './fp_diff.js';
-export { default as FpCalibrate } from './fp_calibrate.js';
+import type { CommandMetaData } from '@adonisjs/core/types/ace';
+export declare function getMetaData(): Promise<CommandMetaData[]>;
+export declare function getCommand(metaData: CommandMetaData): Promise<{
+    commandName: string;
+    serialize(): CommandMetaData;
+} | null>;

package/build/commands/main.js

@@ -1,120 +1,54 @@
-import { a as runInventory, i as runExplain, n as runCount, r as runDiff, s as printResult, t as runCalibrate } from "../runners-Bt8tbISi.js";
-import { BaseCommand, args, flags } from "@adonisjs/core/ace";
-//#region commands/printer.ts
+//#region commands/main.ts
 /**
-* Maps a `RunResult` onto ace's logger.
+* Static index of the commands this package ships.
 *
-* Notes go to `info`, not `log`: they are diagnostics about the run, and under
-* `--json` they must not be mistaken for output.
-*/
-function printerFor(command) {
-	return {
-		log: (message) => command.logger.log(message),
-		error: (message) => command.logger.error(message),
-		note: (message) => command.logger.info(message)
-	};
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-//#endregion
-//#region commands/fp_inventory.ts
-var FpInventory = class extends BaseCommand {
-	static commandName = "fp:inventory";
-	static description = "Extract the raw facts of the application: stores, routes and tracing";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runInventory({
-			root: this.app.makePath(),
-			out: this.out
-		}), printerFor(this));
-	}
-};
-__decorate([flags.string({ description: "Write the inventory as JSON to the given path" })], FpInventory.prototype, "out", void 0);
-//#endregion
-//#region commands/fp_count.ts
-var FpCount = class extends BaseCommand {
-	static commandName = "fp:count";
-	static description = "Count the unadjusted function points of the application";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runCount({
-			root: this.app.makePath(),
-			out: this.out,
-			json: this.json,
-			minCoverage: this.minCoverage
-		}), printerFor(this));
-	}
-};
-__decorate([flags.string({ description: "Write the result as JSON to the given path" })], FpCount.prototype, "out", void 0);
-__decorate([flags.boolean({ description: "Print JSON instead of a table" })], FpCount.prototype, "json", void 0);
-__decorate([flags.number({ description: "Minimum tracing coverage (0 to 1)" })], FpCount.prototype, "minCoverage", void 0);
-//#endregion
-//#region commands/fp_explain.ts
-/**
-* Why a function was counted the way it was.
-*
-* Not a convenience: if function points get invoiced, someone will dispute a
-* number, and a number without provenance is indefensible.
-*/
-var FpExplain = class extends BaseCommand {
-	static commandName = "fp:explain";
-	static description = "Show the provenance of a function's count";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runExplain({
-			root: this.app.makePath(),
-			name: this.name
-		}), printerFor(this));
-	}
-};
-__decorate([args.string({ description: "Function name, e.g. \"POST /books\" or \"Invite\"" })], FpExplain.prototype, "name", void 0);
-//#endregion
-//#region commands/fp_diff.ts
-/**
-* Additions, changes and deletions between two counts — what gets invoiced.
+* AdonisJS resolves a package's commands by importing its `commands` entry and
+* calling `getMetaData()` and `getCommand()`. Exporting the classes instead —
+* which this module did until now — does not merely fail to register them: ace
+* cannot read the entry at all, so EVERY command breaks, `migration:run`
+* included. Adding the package to `adonisrc.ts` made the application worse than
+* not having it.
 *
-* It works on a SAVED count (`fp:count --out`) compared against the current
-* state, never on two checkouts: booting the older version, with possibly
-* different dependencies, is a problem not worth solving.
+* The shape mirrors how `@adonisjs/lucid` exposes its own commands.
 */
-var FpDiff = class extends BaseCommand {
-	static commandName = "fp:diff";
-	static description = "Compare a saved count against the current state of the application";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runDiff({
-			root: this.app.makePath(),
-			previous: this.previous
-		}), printerFor(this));
+const commands = [
+	{
+		commandName: "fp:inventory",
+		importer: () => import("../fp_inventory-Bu6O1Nn0.js")
+	},
+	{
+		commandName: "fp:metrics",
+		importer: () => import("../fp_metrics-MGDppfSa.js")
+	},
+	{
+		commandName: "fp:count",
+		importer: () => import("../fp_count-D21tQ_pv.js")
+	},
+	{
+		commandName: "fp:explain",
+		importer: () => import("../fp_explain-BwFs-LW-.js")
+	},
+	{
+		commandName: "fp:diff",
+		importer: () => import("../fp_diff-D0pHGMgi.js")
+	},
+	{
+		commandName: "fp:calibrate",
+		importer: () => import("../fp_calibrate-iFAec0tA.js")
 	}
-};
-__decorate([args.string({ description: "Path to the JSON produced by `fp:count --out`" })], FpDiff.prototype, "previous", void 0);
-//#endregion
-//#region commands/fp_calibrate.ts
-/**
-* Measures the counter's bias against a manual count.
-*
-* It does NOT apply the factor: calibrating is a decision for whoever signs the
-* contract, and a factor applied silently would stop the count from being
-* reproducible from the code.
-*/
-var FpCalibrate = class extends BaseCommand {
-	static commandName = "fp:calibrate";
-	static description = "Compare the automatic count against manual counts";
-	static options = { startApp: false };
-	async run() {
-		this.exitCode = printResult(await runCalibrate({
-			root: this.app.makePath(),
-			samples: this.samples
-		}), printerFor(this));
-	}
-};
-__decorate([args.string({ description: "CSV of `function,fp` counted by hand" })], FpCalibrate.prototype, "samples", void 0);
+];
+let cache = null;
+async function getMetaData() {
+	if (cache) return cache;
+	cache = await Promise.all(commands.map(async ({ importer }) => {
+		return (await importer()).default.serialize();
+	}));
+	return cache;
+}
+async function getCommand(metaData) {
+	const match = commands.find(({ commandName }) => commandName === metaData.commandName);
+	if (!match) return null;
+	return (await match.importer()).default;
+}
 //#endregion
-export { FpCalibrate, FpCount, FpDiff, FpExplain, FpInventory };
+export { getCommand, getMetaData };

package/build/decorate-D6enDn9D.js

@@ -0,0 +1,24 @@
+//#region commands/printer.ts
+/**
+* Maps a `RunResult` onto ace's logger.
+*
+* Notes go to `info`, not `log`: they are diagnostics about the run, and under
+* `--json` they must not be mistaken for output.
+*/
+function printerFor(command) {
+	return {
+		log: (message) => command.logger.log(message),
+		error: (message) => command.logger.error(message),
+		note: (message) => command.logger.info(message)
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { printerFor as n, __decorate as t };

package/build/fp_calibrate-iFAec0tA.js

@@ -0,0 +1,25 @@
+import { s as printResult, t as runCalibrate } from "./runners-CmxNHuuq.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, args } from "@adonisjs/core/ace";
+//#region commands/fp_calibrate.ts
+/**
+* Measures the counter's bias against a manual count.
+*
+* It does NOT apply the factor: calibrating is a decision for whoever signs the
+* contract, and a factor applied silently would stop the count from being
+* reproducible from the code.
+*/
+var FpCalibrate = class extends BaseCommand {
+	static commandName = "fp:calibrate";
+	static description = "Compare the automatic count against manual counts";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runCalibrate({
+			root: this.app.makePath(),
+			samples: this.samples
+		}), printerFor(this));
+	}
+};
+__decorate([args.string({ description: "CSV of `function,fp` counted by hand" })], FpCalibrate.prototype, "samples", void 0);
+//#endregion
+export { FpCalibrate as default };

package/build/fp_count-D21tQ_pv.js

@@ -0,0 +1,22 @@
+import { n as runCount, s as printResult } from "./runners-CmxNHuuq.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, flags } from "@adonisjs/core/ace";
+//#region commands/fp_count.ts
+var FpCount = class extends BaseCommand {
+	static commandName = "fp:count";
+	static description = "Count the unadjusted function points of the application";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runCount({
+			root: this.app.makePath(),
+			out: this.out,
+			json: this.json,
+			minCoverage: this.minCoverage
+		}), printerFor(this));
+	}
+};
+__decorate([flags.string({ description: "Write the result as JSON to the given path" })], FpCount.prototype, "out", void 0);
+__decorate([flags.boolean({ description: "Print JSON instead of a table" })], FpCount.prototype, "json", void 0);
+__decorate([flags.number({ description: "Minimum tracing coverage (0 to 1)" })], FpCount.prototype, "minCoverage", void 0);
+//#endregion
+export { FpCount as default };

package/build/fp_diff-D0pHGMgi.js

@@ -0,0 +1,25 @@
+import { r as runDiff, s as printResult } from "./runners-CmxNHuuq.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, args } from "@adonisjs/core/ace";
+//#region commands/fp_diff.ts
+/**
+* Additions, changes and deletions between two counts — what gets invoiced.
+*
+* It works on a SAVED count (`fp:count --out`) compared against the current
+* state, never on two checkouts: booting the older version, with possibly
+* different dependencies, is a problem not worth solving.
+*/
+var FpDiff = class extends BaseCommand {
+	static commandName = "fp:diff";
+	static description = "Compare a saved count against the current state of the application";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runDiff({
+			root: this.app.makePath(),
+			previous: this.previous
+		}), printerFor(this));
+	}
+};
+__decorate([args.string({ description: "Path to the JSON produced by `fp:count --out`" })], FpDiff.prototype, "previous", void 0);
+//#endregion
+export { FpDiff as default };

package/build/fp_explain-BwFs-LW-.js

@@ -0,0 +1,24 @@
+import { i as runExplain, s as printResult } from "./runners-CmxNHuuq.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, args } from "@adonisjs/core/ace";
+//#region commands/fp_explain.ts
+/**
+* Why a function was counted the way it was.
+*
+* Not a convenience: if function points get invoiced, someone will dispute a
+* number, and a number without provenance is indefensible.
+*/
+var FpExplain = class extends BaseCommand {
+	static commandName = "fp:explain";
+	static description = "Show the provenance of a function's count";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runExplain({
+			root: this.app.makePath(),
+			name: this.name
+		}), printerFor(this));
+	}
+};
+__decorate([args.string({ description: "Function name, e.g. \"POST /books\" or \"Invite\"" })], FpExplain.prototype, "name", void 0);
+//#endregion
+export { FpExplain as default };

package/build/fp_inventory-Bu6O1Nn0.js

@@ -0,0 +1,18 @@
+import { a as runInventory, s as printResult } from "./runners-CmxNHuuq.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, flags } from "@adonisjs/core/ace";
+//#region commands/fp_inventory.ts
+var FpInventory = class extends BaseCommand {
+	static commandName = "fp:inventory";
+	static description = "Extract the raw facts of the application: stores, routes and tracing";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runInventory({
+			root: this.app.makePath(),
+			out: this.out
+		}), printerFor(this));
+	}
+};
+__decorate([flags.string({ description: "Write the inventory as JSON to the given path" })], FpInventory.prototype, "out", void 0);
+//#endregion
+export { FpInventory as default };

package/build/fp_metrics-MGDppfSa.js

@@ -0,0 +1,20 @@
+import { o as runMetrics, s as printResult } from "./runners-CmxNHuuq.js";
+import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
+import { BaseCommand, flags } from "@adonisjs/core/ace";
+//#region commands/fp_metrics.ts
+var FpMetrics = class extends BaseCommand {
+	static commandName = "fp:metrics";
+	static description = "Density, coupling and conformance, derived from the same inventory";
+	static options = { startApp: false };
+	async run() {
+		this.exitCode = printResult(await runMetrics({
+			root: this.app.makePath(),
+			out: this.out,
+			json: this.json
+		}), printerFor(this));
+	}
+};
+__decorate([flags.string({ description: "Write the metrics as JSON to the given path" })], FpMetrics.prototype, "out", void 0);
+__decorate([flags.boolean({ description: "Print JSON instead of a table" })], FpMetrics.prototype, "json", void 0);
+//#endregion
+export { FpMetrics as default };

package/build/index.d.ts

@@ -1,5 +1,34 @@
+export { configure } from './configure.js';
 export { defineConfig } from './src/define_config.js';
-export type { FunctionPointsConfig } from './src/define_config.js';
+export type { FunctionPointsConfig, FunctionOverride } from './src/define_config.js';
 export * from './src/types.js';
+/**
+ * Counting, programmatically.
+ *
+ * The two front-ends were the only way to reach any of this, so anything built on
+ * top of the package — a ledger, a dashboard, a billing job — had to shell out to
+ * the CLI and parse its output. That is the same defect as the configuration
+ * nobody read and the metrics nobody could run, one layer up.
+ */
+export { analyze, CoverageTooLowError } from './src/pipeline.js';
+export type { Analysis, AnalysisOptions } from './src/pipeline.js';
+/**
+ * Which rules produced a number.
+ *
+ * A ledger row without them cannot be compared to another one: `diffCounts`
+ * refuses counts from different rule sets, and a stored count needs to carry what
+ * it was measured with.
+ */
+export { RULESET, RULESET_VERSION } from './src/albrecht/counter.js';
+/** Change, and what it bills at — AEP §6.3 and §6.5. */
+export { AEP_FACTORS, diffCounts, IncomparableRulesetsError, IncomparableSourcesError, } from './src/albrecht/diff.js';
+export type { ChangeFactors, ChangeReasonFactors, DiffOptions, FunctionPointDiff, } from './src/albrecht/diff.js';
+/** The counterweight: density, coupling and conformance over the same inventory. */
+export { measureConformance, measureStructure } from './src/metrics/structure.js';
+export type { Conformance, ModuleMetrics, StructureMetrics } from './src/metrics/structure.js';
+/** Correction factors against a manual count. */
+export { calibrate, parseSamples } from './src/albrecht/calibration.js';
+export type { Calibration, CalibrationSample, TypeCalibration } from './src/albrecht/calibration.js';
+/** Tracing strategies: the one public extension point. */
 export { BUILTIN_CALL_RESOLVERS } from './src/inventory/resolvers/index.js';
 export type { CallResolver, ResolverContext } from './src/inventory/resolvers/types.js';

package/build/index.js

@@ -1,4 +1,6 @@
-import { n as defineConfig } from "./define_config-DOqWyPwV.js";
+import { configure } from "./configure.js";
+import { a as AEP_FACTORS, c as diffCounts, i as measureStructure, n as parseSamples, o as IncomparableRulesetsError, r as measureConformance, s as IncomparableSourcesError, t as calibrate, u as defineConfig } from "./calibration-8eV8CEix.js";
 import "./src/types.js";
-import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-CU9HKYpn.js";
-export { BUILTIN_CALL_RESOLVERS, defineConfig };
+import { t as BUILTIN_CALL_RESOLVERS } from "./resolvers-CRB6lXoo.js";
+import { i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-CIAydCcT.js";
+export { AEP_FACTORS, BUILTIN_CALL_RESOLVERS, CoverageTooLowError, IncomparableRulesetsError, IncomparableSourcesError, RULESET, RULESET_VERSION, analyze, calibrate, configure, defineConfig, diffCounts, measureConformance, measureStructure, parseSamples };