@bymaksym/loadline 0.1.0
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.
- package/LICENSE +21 -0
- package/README.md +182 -0
- package/bin/loadline.js +50 -0
- package/dist/cli/cli/args.js +324 -0
- package/dist/cli/cli/args.types.js +3 -0
- package/dist/cli/cli/gates.js +173 -0
- package/dist/cli/cli/gates.types.js +3 -0
- package/dist/cli/cli/main.js +156 -0
- package/dist/cli/cli/read-build.js +382 -0
- package/dist/cli/cli/read-build.types.js +3 -0
- package/dist/cli/cli/render-json.js +116 -0
- package/dist/cli/cli/render-json.types.js +10 -0
- package/dist/cli/cli/render-markdown.js +30 -0
- package/dist/cli/cli/render-pr.js +76 -0
- package/dist/cli/cli/render-sarif.js +83 -0
- package/dist/cli/cli/render-text.js +388 -0
- package/dist/cli/cli/report.js +196 -0
- package/dist/cli/cli/report.types.js +3 -0
- package/dist/cli/cli/self-check.js +85 -0
- package/dist/cli/cli/text.js +180 -0
- package/dist/cli/cli/text.types.js +10 -0
- package/dist/cli/src/app/core/analysis/analysis.js +661 -0
- package/dist/cli/src/app/core/analysis/analysis.types.js +6 -0
- package/dist/cli/src/app/core/analysis/barrels.js +128 -0
- package/dist/cli/src/app/core/analysis/blast.js +172 -0
- package/dist/cli/src/app/core/analysis/cycles.js +110 -0
- package/dist/cli/src/app/core/analysis/delivery.js +143 -0
- package/dist/cli/src/app/core/analysis/entries.js +217 -0
- package/dist/cli/src/app/core/analysis/exclusive.js +91 -0
- package/dist/cli/src/app/core/analysis/importers.js +38 -0
- package/dist/cli/src/app/core/analysis/insights.js +202 -0
- package/dist/cli/src/app/core/analysis/insights.types.js +10 -0
- package/dist/cli/src/app/core/analysis/invariant.js +69 -0
- package/dist/cli/src/app/core/analysis/metafile.types.js +44 -0
- package/dist/cli/src/app/core/analysis/module-graph.js +192 -0
- package/dist/cli/src/app/core/analysis/sourcemap.js +231 -0
- package/dist/cli/src/app/core/analysis/sourcemap.types.js +3 -0
- package/dist/cli/src/app/core/analysis/split-drift.js +47 -0
- package/dist/cli/src/app/core/assets/assets.js +296 -0
- package/dist/cli/src/app/core/assets/assets.types.js +11 -0
- package/dist/cli/src/app/core/baseline/baseline.js +0 -0
- package/dist/cli/src/app/core/baseline/baseline.types.js +3 -0
- package/dist/cli/src/app/core/caching/caching.js +241 -0
- package/dist/cli/src/app/core/caching/caching.types.js +10 -0
- package/dist/cli/src/app/core/caching/from-analysis.js +73 -0
- package/dist/cli/src/app/core/config/loadline-config.js +110 -0
- package/dist/cli/src/app/core/config/loadline-config.types.js +12 -0
- package/dist/cli/src/app/core/criteria/criteria.js +228 -0
- package/dist/cli/src/app/core/criteria/criteria.types.js +3 -0
- package/dist/cli/src/app/core/deps/deps.js +225 -0
- package/dist/cli/src/app/core/deps/deps.types.js +15 -0
- package/dist/cli/src/app/core/export/markdown-table.utils.js +40 -0
- package/dist/cli/src/app/core/export/summary.js +72 -0
- package/dist/cli/src/app/core/findings/actions.js +59 -0
- package/dist/cli/src/app/core/findings/assets.js +130 -0
- package/dist/cli/src/app/core/findings/caching.js +165 -0
- package/dist/cli/src/app/core/findings/compose.js +41 -0
- package/dist/cli/src/app/core/findings/deps.js +66 -0
- package/dist/cli/src/app/core/findings/effort.js +117 -0
- package/dist/cli/src/app/core/findings/finding-html.js +13 -0
- package/dist/cli/src/app/core/findings/finding-plain.js +26 -0
- package/dist/cli/src/app/core/findings/finding-text.js +1231 -0
- package/dist/cli/src/app/core/findings/finding.types.js +80 -0
- package/dist/cli/src/app/core/findings/findings.js +514 -0
- package/dist/cli/src/app/core/findings/graph.js +167 -0
- package/dist/cli/src/app/core/findings/own-in-boot.js +88 -0
- package/dist/cli/src/app/core/findings/page.js +49 -0
- package/dist/cli/src/app/core/findings/requests.js +185 -0
- package/dist/cli/src/app/core/findings/scan.js +126 -0
- package/dist/cli/src/app/core/findings/shipped.js +244 -0
- package/dist/cli/src/app/core/findings/situation.js +116 -0
- package/dist/cli/src/app/core/format/format.utils.js +204 -0
- package/dist/cli/src/app/core/i18n/en.js +819 -0
- package/dist/cli/src/app/core/i18n/es.js +822 -0
- package/dist/cli/src/app/core/i18n/ui-strings.js +11 -0
- package/dist/cli/src/app/core/i18n/ui.js +7 -0
- package/dist/cli/src/app/core/intake/bundle-graph.js +346 -0
- package/dist/cli/src/app/core/intake/bundle-graph.types.js +3 -0
- package/dist/cli/src/app/core/intake/dist-files.js +160 -0
- package/dist/cli/src/app/core/intake/index-html.js +292 -0
- package/dist/cli/src/app/core/json/json.utils.js +55 -0
- package/dist/cli/src/app/core/measurement/measurement.types.js +14 -0
- package/dist/cli/src/app/core/project/budget-advice.js +76 -0
- package/dist/cli/src/app/core/project/project-context.js +394 -0
- package/dist/cli/src/app/core/project/project-context.types.js +3 -0
- package/dist/cli/src/app/core/scan/catalog.js +67 -0
- package/dist/cli/src/app/core/scan/scan.js +280 -0
- package/dist/cli/src/app/core/scan/scan.types.js +10 -0
- package/dist/cli/src/app/core/scan/secrets.js +0 -0
- package/dist/cli/src/app/core/situation/situation.js +261 -0
- package/dist/cli/src/app/core/situation/situation.types.js +19 -0
- package/dist/cli/src/app/core/timing/timing.js +87 -0
- package/dist/cli/src/app/core/timing/timing.types.js +3 -0
- package/dist/cli/src/app/core/whatif/defer.js +68 -0
- package/dist/cli/src/app/state/report-messages.utils.js +73 -0
- package/docs/HOW-IT-WORKS.md +1087 -0
- package/loadline.html +78 -0
- package/package.json +154 -0
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/**
|
|
3
|
+
* Five figures and three actions, as a block somebody pastes into a chat.
|
|
4
|
+
*
|
|
5
|
+
* The report is looked at alone; what circulates in a team is a screenshot or a paste. This is that
|
|
6
|
+
* paste, and it is plain text on purpose — it survives a chat window, an issue, a commit message
|
|
7
|
+
* and an email, which no image does.
|
|
8
|
+
*
|
|
9
|
+
* It is a **summary and says so**: the line at the end names the tool and the unit, because a
|
|
10
|
+
* figure without its unit quoted three days later in a meeting is worse than no figure.
|
|
11
|
+
*/
|
|
12
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
13
|
+
exports.summaryText = void 0;
|
|
14
|
+
const actions_1 = require("../findings/actions");
|
|
15
|
+
const format_utils_1 = require("../format/format.utils");
|
|
16
|
+
const WORDS = {
|
|
17
|
+
en: {
|
|
18
|
+
boot: 'Bootstrap',
|
|
19
|
+
trip: 'First trip',
|
|
20
|
+
screens: 'Screens',
|
|
21
|
+
worst: 'Heaviest screen',
|
|
22
|
+
signals: 'Signals',
|
|
23
|
+
actions: 'What to fix first',
|
|
24
|
+
saving: 'All of it is worth',
|
|
25
|
+
none: 'nothing that can be measured',
|
|
26
|
+
tail: (unit) => `— Loadline, figures ${unit}`,
|
|
27
|
+
},
|
|
28
|
+
es: {
|
|
29
|
+
boot: 'Bootstrap',
|
|
30
|
+
trip: 'Primer viaje',
|
|
31
|
+
screens: 'Pantallas',
|
|
32
|
+
worst: 'Pantalla más pesada',
|
|
33
|
+
signals: 'Señales',
|
|
34
|
+
actions: 'Qué arreglar primero',
|
|
35
|
+
saving: 'Todo junto vale',
|
|
36
|
+
none: 'nada que se pueda medir',
|
|
37
|
+
tail: (unit) => `— Loadline, cifras ${unit}`,
|
|
38
|
+
},
|
|
39
|
+
};
|
|
40
|
+
/**
|
|
41
|
+
* @returns plain text, no markup. Three actions rather than all of them: this is the thing that
|
|
42
|
+
* gets read in a chat, and the report it points at is where nothing is left out.
|
|
43
|
+
*/
|
|
44
|
+
const summaryText = (input) => {
|
|
45
|
+
const words = WORDS[input.lang];
|
|
46
|
+
const { analysis, comparison } = input;
|
|
47
|
+
const worst = analysis.screens[0];
|
|
48
|
+
const problems = input.findings.filter(finding => finding.severity === 'high' || finding.severity === 'mid');
|
|
49
|
+
const total = (0, actions_1.totalSaving)(analysis, input.findings);
|
|
50
|
+
const bootLine = comparison
|
|
51
|
+
? `${(0, format_utils_1.formatBytes)(analysis.bootBytes)} (${(0, format_utils_1.formatDelta)(comparison.boot.diff)} vs ${comparison.baselineName})`
|
|
52
|
+
: (0, format_utils_1.formatBytes)(analysis.bootBytes);
|
|
53
|
+
const lines = [
|
|
54
|
+
`Loadline · ${input.name}`,
|
|
55
|
+
'',
|
|
56
|
+
`${words.boot}: ${bootLine}`,
|
|
57
|
+
...(input.firstTrip === null ? [] : [`${words.trip}: ${(0, format_utils_1.formatBytes)(input.firstTrip)}`]),
|
|
58
|
+
`${words.screens}: ${analysis.screens.length}`,
|
|
59
|
+
...(worst ? [`${words.worst}: ${worst.label} — ${(0, format_utils_1.formatBytes)(worst.total)}`] : []),
|
|
60
|
+
`${words.signals}: ${problems.length}`,
|
|
61
|
+
'',
|
|
62
|
+
`${words.actions}:`,
|
|
63
|
+
...(0, actions_1.rankActions)(input.findings)
|
|
64
|
+
.slice(0, 3)
|
|
65
|
+
.map((action, index) => ` ${index + 1}. ${action.finding.title}${action.saving > 0 ? ` — ${(0, format_utils_1.formatBytes)(action.saving)}` : ''}`),
|
|
66
|
+
'',
|
|
67
|
+
`${words.saving}: ${total.counted > 0 ? (0, format_utils_1.formatBytes)(total.bytes) : words.none}`,
|
|
68
|
+
words.tail(input.unit),
|
|
69
|
+
];
|
|
70
|
+
return `${lines.join('\n')}\n`;
|
|
71
|
+
};
|
|
72
|
+
exports.summaryText = summaryText;
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/**
|
|
3
|
+
* What to fix first, and what fixing all of it is worth.
|
|
4
|
+
*
|
|
5
|
+
* Thirty-seven signals well found and in no order are thirty-seven signals nobody reads. These two
|
|
6
|
+
* figures are what turns the report from a description into a decision, and neither of them drops
|
|
7
|
+
* anything: the ranking is an **order**, and every signal is still there underneath it, which is
|
|
8
|
+
* the rule this project holds itself to about grouping rather than trimming.
|
|
9
|
+
*
|
|
10
|
+
* The total is not a sum. Two signals often name the same bytes arriving by two routes — a package
|
|
11
|
+
* in the bootstrap and the barrel that imports it — and adding their savings would promise twice
|
|
12
|
+
* what removing both gives. It is one walk of the graph with every named file taken out at once.
|
|
13
|
+
*/
|
|
14
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
15
|
+
exports.rankActions = exports.totalSaving = void 0;
|
|
16
|
+
const effort_1 = require("./effort");
|
|
17
|
+
/**
|
|
18
|
+
* Everything the signals are worth together.
|
|
19
|
+
*
|
|
20
|
+
* The figures are raw minified bytes inside the chunk, which is the only scale a per-module saving
|
|
21
|
+
* can honestly be in: gzip compresses a chunk as a whole, so there is no compressed share of one
|
|
22
|
+
* module to subtract.
|
|
23
|
+
*/
|
|
24
|
+
const totalSaving = (analysis, findings) => {
|
|
25
|
+
const insights = analysis.insights();
|
|
26
|
+
const files = new Set();
|
|
27
|
+
let counted = 0;
|
|
28
|
+
for (const finding of findings) {
|
|
29
|
+
if (!finding.sources || finding.sources.length === 0) {
|
|
30
|
+
continue;
|
|
31
|
+
}
|
|
32
|
+
counted += 1;
|
|
33
|
+
for (const file of finding.sources) {
|
|
34
|
+
files.add(file);
|
|
35
|
+
}
|
|
36
|
+
}
|
|
37
|
+
const bytes = files.size > 0 ? insights.exclusiveOf(files) : 0;
|
|
38
|
+
return { bytes, before: insights.bootTotal, after: Math.max(0, insights.bootTotal - bytes), counted };
|
|
39
|
+
};
|
|
40
|
+
exports.totalSaving = totalSaving;
|
|
41
|
+
/**
|
|
42
|
+
* The signals in the order somebody would do them.
|
|
43
|
+
*
|
|
44
|
+
* Only what can be acted on: a signal whose effort is `none` is context — a verdict, a note about
|
|
45
|
+
* the report itself, a growth against the baseline — and putting "the bootstrap has grown" on a
|
|
46
|
+
* list of things to do would be a category mistake.
|
|
47
|
+
*/
|
|
48
|
+
const rankActions = (findings) => findings
|
|
49
|
+
.map((finding) => {
|
|
50
|
+
const effort = effort_1.EFFORT[finding.kind];
|
|
51
|
+
const saving = finding.saving ?? 0;
|
|
52
|
+
const weight = effort_1.EFFORT_WEIGHT[effort];
|
|
53
|
+
return { finding, saving, effort, score: weight > 0 ? saving / weight : 0 };
|
|
54
|
+
})
|
|
55
|
+
.filter(action => action.effort !== 'none')
|
|
56
|
+
.toSorted((a, b) => b.score - a.score ||
|
|
57
|
+
// With nothing to weigh them by, the severity the signal already carries decides.
|
|
58
|
+
Number(b.finding.severity === 'high') - Number(a.finding.severity === 'high'));
|
|
59
|
+
exports.rankActions = rankActions;
|
|
@@ -0,0 +1,130 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/**
|
|
3
|
+
* The signals about what the build folder holds besides JavaScript.
|
|
4
|
+
*
|
|
5
|
+
* They are the answer to the sentence at the top of `assets.ts`: nobody downloads JavaScript, they
|
|
6
|
+
* download a page. Seven weights of one typeface to use two is a 300 kB finding that no bundle
|
|
7
|
+
* analyser shows, because every one of them stops at the JavaScript.
|
|
8
|
+
*
|
|
9
|
+
* Nothing here promises a saving it cannot measure. "This PNG would be 310 kB in AVIF" is a number
|
|
10
|
+
* nobody weighed; what is said is what the file weighs, what format it is in, and whether the
|
|
11
|
+
* better version of it is already sitting in the same folder.
|
|
12
|
+
*/
|
|
13
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
14
|
+
exports.buildAssetFindings = void 0;
|
|
15
|
+
const format_utils_1 = require("../format/format.utils");
|
|
16
|
+
const finding_html_1 = require("./finding-html");
|
|
17
|
+
const finding_text_1 = require("./finding-text");
|
|
18
|
+
const named = (items) => items.map(item => (0, finding_html_1.mono)(item)).join(', ');
|
|
19
|
+
const buildAssetFindings = (assets, lang, c) => {
|
|
20
|
+
const text = finding_text_1.TEXT[lang];
|
|
21
|
+
const findings = [];
|
|
22
|
+
// 1 · Fonts. The one place where "you are shipping the same face twice" is a fact rather than
|
|
23
|
+
// an opinion: both files are in the folder.
|
|
24
|
+
const fonts = assets.fonts;
|
|
25
|
+
const fontBytes = fonts.reduce((sum, family) => sum + family.bytes, 0);
|
|
26
|
+
const superseded = fonts.flatMap(family => family.superseded);
|
|
27
|
+
const manyWeights = fonts.filter(family => family.files.length > 2);
|
|
28
|
+
if (fonts.length > 0 && (fontBytes >= c.shippedMinBytes || superseded.length > 0)) {
|
|
29
|
+
findings.push({
|
|
30
|
+
severity: superseded.length > 0 || manyWeights.length > 0 ? 'mid' : 'info',
|
|
31
|
+
kind: 'fonts',
|
|
32
|
+
...text.fonts({
|
|
33
|
+
families: fonts.length,
|
|
34
|
+
files: fonts.reduce((sum, family) => sum + family.files.length, 0),
|
|
35
|
+
size: (0, format_utils_1.formatBytes)(fontBytes),
|
|
36
|
+
superseded: named(superseded),
|
|
37
|
+
preloaded: named(fonts.flatMap(family => family.preloaded)),
|
|
38
|
+
list: fonts
|
|
39
|
+
.map(family => `${(0, finding_html_1.mono)(family.name)} — ${family.files.length} files, ${(0, format_utils_1.formatBytes)(family.bytes)}, ${family.formats.join('/')}`)
|
|
40
|
+
.join(' · '),
|
|
41
|
+
}),
|
|
42
|
+
});
|
|
43
|
+
}
|
|
44
|
+
// 2 · Pictures and video. Named, weighed, and nothing recompressed.
|
|
45
|
+
const media = assets.media;
|
|
46
|
+
const mediaBytes = media.reduce((sum, file) => sum + file.bytes, 0);
|
|
47
|
+
const outdated = media.filter(file => file.modernNeighbour);
|
|
48
|
+
if (media.length > 0 && mediaBytes >= c.shippedMinBytes) {
|
|
49
|
+
findings.push({
|
|
50
|
+
severity: outdated.length > 0 ? 'mid' : 'info',
|
|
51
|
+
kind: 'media',
|
|
52
|
+
...text.media({
|
|
53
|
+
count: media.length,
|
|
54
|
+
size: (0, format_utils_1.formatBytes)(mediaBytes),
|
|
55
|
+
inPage: media.filter(file => file.inPage).length,
|
|
56
|
+
outdated: outdated.length,
|
|
57
|
+
outdatedList: named(outdated.map(file => `${file.name} → .${file.modernNeighbour}`)),
|
|
58
|
+
list: media
|
|
59
|
+
.map(file => `${(0, finding_html_1.mono)(file.name)} (${(0, format_utils_1.formatBytes)(file.bytes)}${file.inPage ? ', in the page' : ''})`)
|
|
60
|
+
.join(' · '),
|
|
61
|
+
}),
|
|
62
|
+
});
|
|
63
|
+
}
|
|
64
|
+
// 3 · The same file under two names. Only when the contents were compared: a list built from
|
|
65
|
+
// sizes alone would be a guess dressed as a finding.
|
|
66
|
+
const duplicates = assets.duplicates;
|
|
67
|
+
const first = duplicates[0];
|
|
68
|
+
if (first) {
|
|
69
|
+
findings.push({
|
|
70
|
+
severity: 'mid',
|
|
71
|
+
kind: 'duplicateAssets',
|
|
72
|
+
...text.duplicateAssets({
|
|
73
|
+
count: duplicates.length,
|
|
74
|
+
size: (0, format_utils_1.formatBytes)(duplicates.reduce((sum, entry) => sum + entry.wasted, 0)),
|
|
75
|
+
list: duplicates.map(entry => `${named(entry.names)} (${(0, format_utils_1.formatBytes)(entry.bytes)} each)`).join(' · '),
|
|
76
|
+
}),
|
|
77
|
+
});
|
|
78
|
+
}
|
|
79
|
+
// 3b · What the page fetches for a screen nobody has opened yet.
|
|
80
|
+
//
|
|
81
|
+
// Not part of any first-load figure, on purpose — a prefetch is for the next navigation.
|
|
82
|
+
// But it is fetched on this visit: measured against a real Nuxt build, Chrome pulled all
|
|
83
|
+
// three prefetched chunks down during the first page load. That changes what the screens
|
|
84
|
+
// table means, because a screen the visitor already holds does not cost what the row says,
|
|
85
|
+
// and nothing in the report said a word about it.
|
|
86
|
+
const prefetched = assets.prefetched;
|
|
87
|
+
if (prefetched.length > 0) {
|
|
88
|
+
findings.push({
|
|
89
|
+
severity: assets.prefetchedBytes >= c.shippedMinBytes ? 'mid' : 'info',
|
|
90
|
+
kind: 'prefetched',
|
|
91
|
+
...text.prefetched({
|
|
92
|
+
count: prefetched.length,
|
|
93
|
+
size: (0, format_utils_1.formatBytes)(assets.prefetchedBytes),
|
|
94
|
+
list: prefetched.map(file => `${(0, finding_html_1.mono)(file.name)} (${(0, format_utils_1.formatBytes)(file.bytes)})`).join(' · '),
|
|
95
|
+
}),
|
|
96
|
+
});
|
|
97
|
+
}
|
|
98
|
+
// 4 · What nothing in the folder names. The same idea as the `unreachable` signal, one level
|
|
99
|
+
// out: that one looks at chunks of JavaScript, this at everything else.
|
|
100
|
+
const orphans = assets.unreferenced;
|
|
101
|
+
const orphanBytes = orphans.reduce((sum, file) => sum + file.bytes, 0);
|
|
102
|
+
if (assets.referencesRead && orphans.length > 0 && orphanBytes >= c.shippedMinBytes) {
|
|
103
|
+
findings.push({
|
|
104
|
+
severity: 'mid',
|
|
105
|
+
kind: 'unreferencedAssets',
|
|
106
|
+
...text.unreferencedAssets({
|
|
107
|
+
count: orphans.length,
|
|
108
|
+
size: (0, format_utils_1.formatBytes)(orphanBytes),
|
|
109
|
+
list: orphans.map(file => `${(0, finding_html_1.mono)(file.path)} (${(0, format_utils_1.formatBytes)(file.bytes)})`).join(' · '),
|
|
110
|
+
}),
|
|
111
|
+
});
|
|
112
|
+
}
|
|
113
|
+
// 5 · Pictures hiding inside the figure that matters most. They cannot be deferred, they are
|
|
114
|
+
// not cached apart, and they appear in no list of assets anywhere.
|
|
115
|
+
const inlined = assets.inlined;
|
|
116
|
+
if (assets.inlinedBytes >= c.shippedMinBytes) {
|
|
117
|
+
findings.push({
|
|
118
|
+
severity: 'mid',
|
|
119
|
+
kind: 'inlinedData',
|
|
120
|
+
...text.inlinedData({
|
|
121
|
+
count: inlined.reduce((sum, row) => sum + row.count, 0),
|
|
122
|
+
size: (0, format_utils_1.formatBytes)(assets.inlinedBytes),
|
|
123
|
+
types: [...new Set(inlined.flatMap(row => row.types))].join(', '),
|
|
124
|
+
list: inlined.map(row => `${(0, finding_html_1.mono)(row.chunk)} — ${row.count} (${(0, format_utils_1.formatBytes)(row.bytes)})`).join(' · '),
|
|
125
|
+
}),
|
|
126
|
+
});
|
|
127
|
+
}
|
|
128
|
+
return findings;
|
|
129
|
+
};
|
|
130
|
+
exports.buildAssetFindings = buildAssetFindings;
|
|
@@ -0,0 +1,165 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/**
|
|
3
|
+
* The three signals about the update rather than the first visit.
|
|
4
|
+
*
|
|
5
|
+
* Nobody looks at this and it is half the real cost. Almost every visit to a running application is
|
|
6
|
+
* somebody who already had yesterday's version, and what they download is not the bundle — it is
|
|
7
|
+
* whatever of it changed name.
|
|
8
|
+
*/
|
|
9
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
10
|
+
exports.buildCachingFindings = exports.buildCascadeShapeFindings = void 0;
|
|
11
|
+
const blast_1 = require("../analysis/blast");
|
|
12
|
+
const format_utils_1 = require("../format/format.utils");
|
|
13
|
+
const situation_1 = require("../situation/situation");
|
|
14
|
+
const finding_html_1 = require("./finding-html");
|
|
15
|
+
const finding_text_1 = require("./finding-text");
|
|
16
|
+
/**
|
|
17
|
+
* How exposed this build is to the hash cascade, from its own topology.
|
|
18
|
+
*
|
|
19
|
+
* It needs no baseline, which is why it is not in the builder below: a single build already says
|
|
20
|
+
* whether its names are concentrated in one small file or spread across every chunk.
|
|
21
|
+
*
|
|
22
|
+
* **It exists to stop a sentence being said.** "webpack does not have this problem" is the kind of
|
|
23
|
+
* half-truth that ends a discussion: what webpack does is emit a runtime chunk, which works, and
|
|
24
|
+
* which has to be tiny and inlined or the cost comes straight back. Stated as a topology instead
|
|
25
|
+
* of a bundler name, the claim is checkable against any build, this one included.
|
|
26
|
+
*
|
|
27
|
+
* The topology says how far a change travels. How much that costs is a different question, and the
|
|
28
|
+
* only answers to it are in `situation` — how often this deploys and how many people come back.
|
|
29
|
+
* Without them the shape is described and the colour withheld, which is where this started.
|
|
30
|
+
*/
|
|
31
|
+
const buildCascadeShapeFindings = (analysis, lang, situation = situation_1.EMPTY_SITUATION) => {
|
|
32
|
+
const shape = (0, blast_1.cascadeShapeOf)(analysis);
|
|
33
|
+
// Nothing to say about a build with no chunk that names several others: there is no shape yet.
|
|
34
|
+
if (!shape.hub || shape.names < 2) {
|
|
35
|
+
return [];
|
|
36
|
+
}
|
|
37
|
+
const exposure = (0, situation_1.cascadeExposure)(situation);
|
|
38
|
+
return [
|
|
39
|
+
{
|
|
40
|
+
// The severity of a cascade is decided by how often this deploys and how many visitors
|
|
41
|
+
// return, and neither is knowable from a build folder — so with nobody having said, the
|
|
42
|
+
// topology is named, the level is named, and the colour is not claimed. `high` risk
|
|
43
|
+
// means "one leaf moves everything", not "this is bad for you".
|
|
44
|
+
//
|
|
45
|
+
// Somebody answering the two questions is what closes that gap, and it only ever closes
|
|
46
|
+
// it upwards: a declared answer may raise this and may not lower it, which is why there
|
|
47
|
+
// is no branch here taking `low` below `info`. The one that exists needs both halves —
|
|
48
|
+
// a hub-and-spoke build that deploys twice a year costs nothing, and a flat one that
|
|
49
|
+
// deploys hourly costs little.
|
|
50
|
+
severity: exposure === 'high' && shape.risk === 'high' ? 'mid' : 'info',
|
|
51
|
+
kind: 'cascadeShape',
|
|
52
|
+
...finding_text_1.TEXT[lang].cascadeShape({
|
|
53
|
+
risk: shape.risk,
|
|
54
|
+
hub: shape.hub,
|
|
55
|
+
names: shape.names,
|
|
56
|
+
named: shape.named,
|
|
57
|
+
size: (0, format_utils_1.formatBytes)(shape.bytes),
|
|
58
|
+
chunks: analysis.allChunks.length,
|
|
59
|
+
exposure,
|
|
60
|
+
perWeek: (0, situation_1.invalidationsPerWeek)(situation),
|
|
61
|
+
}),
|
|
62
|
+
},
|
|
63
|
+
];
|
|
64
|
+
};
|
|
65
|
+
exports.buildCascadeShapeFindings = buildCascadeShapeFindings;
|
|
66
|
+
const buildCachingFindings = (caching, lang, c, situation = situation_1.EMPTY_SITUATION) => {
|
|
67
|
+
const text = finding_text_1.TEXT[lang];
|
|
68
|
+
const findings = [];
|
|
69
|
+
// 1 · What the update costs. The figure that does not exist anywhere else, and the one this
|
|
70
|
+
// whole group is for.
|
|
71
|
+
const update = caching.update;
|
|
72
|
+
if (update && update.bytes >= c.growthMinBytes) {
|
|
73
|
+
const moved = [...update.changed, ...update.added];
|
|
74
|
+
// The counterfactual, when the edges were there to work it out. Without it the percentage
|
|
75
|
+
// is a number to be alarmed by; with it, it is a number that says where to look.
|
|
76
|
+
const cascade = update.cascade;
|
|
77
|
+
const exposure = (0, situation_1.cascadeExposure)(situation);
|
|
78
|
+
findings.push({
|
|
79
|
+
// **The colour is withheld until somebody says, and the figure never is.**
|
|
80
|
+
//
|
|
81
|
+
// Whether half a build being re-downloaded is a problem depends on two facts nothing in
|
|
82
|
+
// a build folder has: how often this deploys, and how many of the people opening it
|
|
83
|
+
// tomorrow had it open today. Daily deploys to an audience that returns every morning
|
|
84
|
+
// make this the most expensive line in the report; a quarterly release to first-time
|
|
85
|
+
// visitors makes it irrelevant. Colouring it without those two facts would be picking
|
|
86
|
+
// one of the two worlds at random, so with nobody having answered the fact is shown raw
|
|
87
|
+
// and the copy says what would decide it.
|
|
88
|
+
//
|
|
89
|
+
// Those two facts are questions two and three, and this is the line they were for. Note
|
|
90
|
+
// what the condition cannot do: `moderate` and `low` leave the severity exactly where
|
|
91
|
+
// it was. An answer may raise this and may not lower it — otherwise the cheapest way to
|
|
92
|
+
// a quiet report would be to answer the questions optimistically.
|
|
93
|
+
//
|
|
94
|
+
// `c` stays in the signature because the floor above still uses it: below what moves
|
|
95
|
+
// between two builds anyway there is nothing to report at all.
|
|
96
|
+
severity: exposure === 'high' ? 'mid' : 'info',
|
|
97
|
+
kind: 'updateWeight',
|
|
98
|
+
...text.updateWeight({
|
|
99
|
+
size: (0, format_utils_1.formatBytes)(update.bytes),
|
|
100
|
+
fresh: (0, format_utils_1.formatBytes)(update.fresh),
|
|
101
|
+
pct: Math.round(update.ratio * 100),
|
|
102
|
+
reused: update.reused,
|
|
103
|
+
count: moved.length,
|
|
104
|
+
list: moved.map(file => `${(0, finding_html_1.mono)(file.name)} (${(0, format_utils_1.formatBytes)(file.bytes)})`).join(' · '),
|
|
105
|
+
removed: update.removed.map(file => (0, finding_html_1.mono)(file.name)).join(', '),
|
|
106
|
+
roots: cascade?.roots.length ?? 0,
|
|
107
|
+
rootSize: (0, format_utils_1.formatBytes)(cascade?.rootBytes ?? 0),
|
|
108
|
+
carried: cascade?.carried.length ?? 0,
|
|
109
|
+
carriedSize: (0, format_utils_1.formatBytes)(cascade?.carriedBytes ?? 0),
|
|
110
|
+
rootList: (cascade?.roots ?? []).map(name => (0, finding_html_1.mono)(name)).join(', '),
|
|
111
|
+
exposure,
|
|
112
|
+
perWeek: (0, situation_1.invalidationsPerWeek)(situation),
|
|
113
|
+
}),
|
|
114
|
+
});
|
|
115
|
+
}
|
|
116
|
+
// 2 · The cause behind that symptom: a chunk holding both what changes and what does not.
|
|
117
|
+
// The floor is the one that already means "smaller than what moves between two builds": what
|
|
118
|
+
// this signal costs IS a re-download on every deploy, so below that it costs nothing at all.
|
|
119
|
+
// Without it, a four-hundred-byte application with one chunk raises it, truthfully and uselessly.
|
|
120
|
+
const unstable = caching.unstable;
|
|
121
|
+
const wasted = unstable.reduce((sum, chunk) => sum + chunk.vendorBytes, 0);
|
|
122
|
+
const worst = wasted >= c.growthMinBytes ? unstable[0] : undefined;
|
|
123
|
+
if (worst) {
|
|
124
|
+
findings.push({
|
|
125
|
+
severity: worst.inBoot ? 'mid' : 'info',
|
|
126
|
+
kind: 'unstableChunk',
|
|
127
|
+
...text.unstableChunk({
|
|
128
|
+
count: unstable.length,
|
|
129
|
+
name: worst.name,
|
|
130
|
+
pct: Math.round(worst.vendorRatio * 100),
|
|
131
|
+
size: (0, format_utils_1.formatBytes)(wasted),
|
|
132
|
+
inBoot: worst.inBoot,
|
|
133
|
+
list: unstable
|
|
134
|
+
.map(chunk => `${(0, finding_html_1.mono)(chunk.name)} — ${Math.round(chunk.vendorRatio * 100)} % ${(0, format_utils_1.formatBytes)(chunk.vendorBytes)}${chunk.inBoot ? ' (bootstrap)' : ''}`)
|
|
135
|
+
.join(' · '),
|
|
136
|
+
}),
|
|
137
|
+
});
|
|
138
|
+
}
|
|
139
|
+
// 3 · Names a browser cannot keep. Informative almost always; when it fires on something big
|
|
140
|
+
// the page asks for, every visit revalidates it.
|
|
141
|
+
const unhashable = caching.unhashable;
|
|
142
|
+
const first = unhashable[0];
|
|
143
|
+
if (first) {
|
|
144
|
+
const inPage = unhashable.filter(file => file.inPage);
|
|
145
|
+
const bytes = inPage.reduce((sum, file) => sum + file.bytes, 0);
|
|
146
|
+
findings.push({
|
|
147
|
+
severity: bytes >= c.growthMinBytes || unhashable.some(file => file.reason === 'query') ? 'mid' : 'info',
|
|
148
|
+
kind: 'unhashable',
|
|
149
|
+
...text.unhashable({
|
|
150
|
+
count: unhashable.length,
|
|
151
|
+
inPage: inPage.length,
|
|
152
|
+
size: (0, format_utils_1.formatBytes)(bytes),
|
|
153
|
+
query: unhashable
|
|
154
|
+
.filter(file => file.reason === 'query')
|
|
155
|
+
.map(file => (0, finding_html_1.mono)(file.path))
|
|
156
|
+
.join(', '),
|
|
157
|
+
list: unhashable
|
|
158
|
+
.map(file => `${(0, finding_html_1.mono)(file.path)} (${(0, format_utils_1.formatBytes)(file.bytes)}${file.inPage ? ', in the page' : ''})`)
|
|
159
|
+
.join(' · '),
|
|
160
|
+
}),
|
|
161
|
+
});
|
|
162
|
+
}
|
|
163
|
+
return findings;
|
|
164
|
+
};
|
|
165
|
+
exports.buildCachingFindings = buildCachingFindings;
|
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/**
|
|
3
|
+
* The order the signals are read in. Which signals exist is `findings.ts`; this is the separate
|
|
4
|
+
* decision of what leads and what is a footnote, and it is kept apart because the page and the
|
|
5
|
+
* command both make it. Two copies of this ordering would mean the terminal and the report
|
|
6
|
+
* disagreeing about what the main problem is.
|
|
7
|
+
*/
|
|
8
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
9
|
+
exports.composeFindings = void 0;
|
|
10
|
+
/** `info` and `ok` are context, not something to act on. */
|
|
11
|
+
const isProblem = (finding) => finding.severity === 'high' || finding.severity === 'mid';
|
|
12
|
+
const composeFindings = (sources) => {
|
|
13
|
+
const { base, fromComparison, fromContext, fromMeasurement, fromBuild = [] } = sources;
|
|
14
|
+
const extra = [...fromComparison, ...fromContext, ...fromBuild];
|
|
15
|
+
if (extra.length === 0 && fromMeasurement.length === 0) {
|
|
16
|
+
return base;
|
|
17
|
+
}
|
|
18
|
+
// A browser measurement leads: it is the only part of the report that was measured rather than
|
|
19
|
+
// computed, so what it says about that screen overrules what was worked out.
|
|
20
|
+
const problems = [
|
|
21
|
+
...fromMeasurement.filter(finding => isProblem(finding)),
|
|
22
|
+
...base.filter(finding => isProblem(finding)),
|
|
23
|
+
...extra.filter(finding => isProblem(finding)),
|
|
24
|
+
];
|
|
25
|
+
/**
|
|
26
|
+
* The "nothing stands out" card only makes sense when nothing else is there to read, and what
|
|
27
|
+
* "else" means is a **problem** — not any card at all.
|
|
28
|
+
*
|
|
29
|
+
* It used to mean any card, because `base` was kept whole or dropped whole on the strength of
|
|
30
|
+
* anything in it that was not `ok`. Every context card in `base` therefore counted: a build with
|
|
31
|
+
* no problems and one informative note lost the card that says it is fine, and read as a report
|
|
32
|
+
* with a finding in it. One test build exists precisely to catch that shape — an application with
|
|
33
|
+
* nothing lazy at all, which has to say "everything is in the bootstrap" and stay a report — and
|
|
34
|
+
* it is what caught this.
|
|
35
|
+
*/
|
|
36
|
+
const notes = [...base, ...fromMeasurement, ...extra]
|
|
37
|
+
.filter(finding => !isProblem(finding))
|
|
38
|
+
.filter(finding => problems.length === 0 || finding.kind !== 'clean');
|
|
39
|
+
return [...problems, ...notes];
|
|
40
|
+
};
|
|
41
|
+
exports.composeFindings = composeFindings;
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/**
|
|
3
|
+
* The two signals that come from a lock file and an audit report — two files the person already has
|
|
4
|
+
* on their disk, dropped through the same door `angular.json` goes through.
|
|
5
|
+
*
|
|
6
|
+
* The crossing is the part neither side can do alone. `pnpm audit` knows there are 47
|
|
7
|
+
* vulnerabilities and nothing about which of them a browser downloads; this report knows what a
|
|
8
|
+
* browser downloads and nothing about vulnerabilities. Together: "3 of your 47 are in the first
|
|
9
|
+
* load and everybody downloads them", which is one afternoon well aimed rather than a backlog.
|
|
10
|
+
*
|
|
11
|
+
* And nothing goes out to the network to do it.
|
|
12
|
+
*/
|
|
13
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
14
|
+
exports.buildDepsFindings = void 0;
|
|
15
|
+
const format_utils_1 = require("../format/format.utils");
|
|
16
|
+
const finding_html_1 = require("./finding-html");
|
|
17
|
+
const finding_text_1 = require("./finding-text");
|
|
18
|
+
const buildDepsFindings = (deps, lang, c) => {
|
|
19
|
+
const text = finding_text_1.TEXT[lang];
|
|
20
|
+
const findings = [];
|
|
21
|
+
// 1 · The advisories that actually ship. Everything else is real and is not what a browser
|
|
22
|
+
// downloads, which is exactly the distinction that turns a list of 47 into a list of 3.
|
|
23
|
+
const shipped = deps.shipped;
|
|
24
|
+
const first = shipped[0];
|
|
25
|
+
if (deps.auditRead && first) {
|
|
26
|
+
const inBoot = shipped.filter(advisory => advisory.inBoot);
|
|
27
|
+
findings.push({
|
|
28
|
+
severity: inBoot.some(advisory => advisory.severity === 'critical' || advisory.severity === 'high')
|
|
29
|
+
? 'high'
|
|
30
|
+
: 'mid',
|
|
31
|
+
kind: 'vulnerable',
|
|
32
|
+
...text.vulnerable({
|
|
33
|
+
shipped: shipped.length,
|
|
34
|
+
total: shipped.length + deps.notShipped.length,
|
|
35
|
+
inBoot: inBoot.length,
|
|
36
|
+
worst: first.package,
|
|
37
|
+
list: shipped
|
|
38
|
+
.map(advisory => `${(0, finding_html_1.mono)(advisory.package)} ${advisory.severity}${advisory.inBoot ? ', bootstrap' : ''} (${(0, format_utils_1.formatBytes)(advisory.bytes)}) — ${advisory.title}`)
|
|
39
|
+
.join(' · '),
|
|
40
|
+
elsewhere: deps.notShipped.map(advisory => (0, finding_html_1.mono)(advisory.package)).join(', '),
|
|
41
|
+
}),
|
|
42
|
+
});
|
|
43
|
+
}
|
|
44
|
+
// 2 · What is in the bundle that nobody asked for directly. The lock file is what turns "who
|
|
45
|
+
// brings this in" from a guess into an answer.
|
|
46
|
+
const transitive = deps.transitive.filter(entry => entry.bytes >= c.bootPackageMinBytes);
|
|
47
|
+
const heaviest = transitive[0];
|
|
48
|
+
if (deps.lockRead && heaviest) {
|
|
49
|
+
const bytes = transitive.reduce((sum, entry) => sum + entry.bytes, 0);
|
|
50
|
+
findings.push({
|
|
51
|
+
severity: 'info',
|
|
52
|
+
kind: 'transitive',
|
|
53
|
+
...text.transitive({
|
|
54
|
+
count: transitive.length,
|
|
55
|
+
size: (0, format_utils_1.formatBytes)(bytes),
|
|
56
|
+
worst: heaviest.name,
|
|
57
|
+
worstSize: (0, format_utils_1.formatBytes)(heaviest.bytes),
|
|
58
|
+
list: transitive
|
|
59
|
+
.map(entry => `${(0, finding_html_1.mono)(entry.name)} (${(0, format_utils_1.formatBytes)(entry.bytes)}${entry.inBoot ? ', bootstrap' : ''})${entry.chain.length > 0 ? ` — via ${entry.chain.join(' › ')}` : ''}`)
|
|
60
|
+
.join(' · '),
|
|
61
|
+
}),
|
|
62
|
+
});
|
|
63
|
+
}
|
|
64
|
+
return findings;
|
|
65
|
+
};
|
|
66
|
+
exports.buildDepsFindings = buildDepsFindings;
|
|
@@ -0,0 +1,117 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/**
|
|
3
|
+
* What each signal costs to act on.
|
|
4
|
+
*
|
|
5
|
+
* It is a property of the **kind** of signal, not a calculation: there is nothing in a metafile
|
|
6
|
+
* that says how long a refactor takes, and pretending to compute it would be inventing a figure.
|
|
7
|
+
* Written once, here, so the same claim is made in the page and in the terminal.
|
|
8
|
+
*
|
|
9
|
+
* Why it exists: without it, ordering the signals by what they save puts the 400 kB fix that costs
|
|
10
|
+
* two weeks ahead of the 90 kB one that costs ten minutes, and the person who opens the report on
|
|
11
|
+
* a Monday does neither.
|
|
12
|
+
*/
|
|
13
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
14
|
+
exports.EFFORT = exports.EFFORT_WEIGHT = void 0;
|
|
15
|
+
/** How the three levels order against each other when ranking what to do first. */
|
|
16
|
+
exports.EFFORT_WEIGHT = { config: 1, import: 2, refactor: 5, none: 0 };
|
|
17
|
+
/**
|
|
18
|
+
* The table. Every kind appears: a missing entry would silently rank as free, and a signal nobody
|
|
19
|
+
* assigned an effort to is exactly the one that would then lead the list.
|
|
20
|
+
*/
|
|
21
|
+
exports.EFFORT = {
|
|
22
|
+
// One import moved, or one import narrowed.
|
|
23
|
+
bootLazy: 'import',
|
|
24
|
+
ownInBoot: 'refactor',
|
|
25
|
+
mixedImport: 'import',
|
|
26
|
+
ownBarrel: 'import',
|
|
27
|
+
packageBarrel: 'import',
|
|
28
|
+
locales: 'import',
|
|
29
|
+
commonJs: 'import',
|
|
30
|
+
heavy: 'import',
|
|
31
|
+
// A line of configuration: a budget, an override, a preload link, a chunking rule.
|
|
32
|
+
dupes: 'config',
|
|
33
|
+
vulnerable: 'config',
|
|
34
|
+
paidTwice: 'config',
|
|
35
|
+
bootWaves: 'config',
|
|
36
|
+
sourceMaps: 'config',
|
|
37
|
+
sourceExposed: 'config',
|
|
38
|
+
devLeftovers: 'config',
|
|
39
|
+
budgetNone: 'config',
|
|
40
|
+
budgetNotBuilt: 'config',
|
|
41
|
+
budgetWarnOnly: 'config',
|
|
42
|
+
budgetTooHigh: 'config',
|
|
43
|
+
dataAsCode: 'config',
|
|
44
|
+
unstableChunk: 'config',
|
|
45
|
+
unhashable: 'config',
|
|
46
|
+
inlinedData: 'config',
|
|
47
|
+
duplicateAssets: 'config',
|
|
48
|
+
unreferencedAssets: 'config',
|
|
49
|
+
fonts: 'config',
|
|
50
|
+
media: 'config',
|
|
51
|
+
// Code has to move, and the move is not local.
|
|
52
|
+
shared: 'refactor',
|
|
53
|
+
bigFile: 'refactor',
|
|
54
|
+
slowScreens: 'refactor',
|
|
55
|
+
manyRequests: 'refactor',
|
|
56
|
+
cycles: 'refactor',
|
|
57
|
+
twinScreens: 'refactor',
|
|
58
|
+
measuredEager: 'refactor',
|
|
59
|
+
// Nothing to act on: context, a verdict, or something about the report rather than the build.
|
|
60
|
+
clean: 'none',
|
|
61
|
+
unreachable: 'none',
|
|
62
|
+
// Context when it only means "no breakdown by package", but on a folder whose every screen row
|
|
63
|
+
// is a content hash it is the one thing to do before anything else on the list can be acted on:
|
|
64
|
+
// you cannot move a screen's code when you cannot tell which screen the row is. And the fix is
|
|
65
|
+
// a flag — `--stats-json`, or source maps on — so it belongs with the configuration ones.
|
|
66
|
+
noSourceMaps: 'config',
|
|
67
|
+
// The same shape of thing and the same way out: a flag on the build, and the figures inside the
|
|
68
|
+
// chunks stop reading high. It is about the report rather than the bundle, and it is still the
|
|
69
|
+
// first thing to do — every saving on the list below is quoted in the unit it corrects.
|
|
70
|
+
splitDrift: 'config',
|
|
71
|
+
// A `preconnect` is one tag in the `<head>`, and it is the whole of what can be done about a
|
|
72
|
+
// handshake short of moving the files back. When the page already warms them there is nothing
|
|
73
|
+
// to do, and the signal drops to context — the effort is the same either way.
|
|
74
|
+
// Compression, cache headers and the protocol are all one line in a server or CDN
|
|
75
|
+
// configuration, and none of them is a change to this project's code.
|
|
76
|
+
servedUncompressed: 'config',
|
|
77
|
+
revalidated: 'config',
|
|
78
|
+
poolExhausted: 'config',
|
|
79
|
+
// Observations. Nothing to do about them: they are the frame the rest is read through, and a
|
|
80
|
+
// measurement that agrees with the computation is a result, not a task.
|
|
81
|
+
measuredWaves: 'none',
|
|
82
|
+
thirdPartyLoad: 'none',
|
|
83
|
+
swControlling: 'none',
|
|
84
|
+
measuredOrigin: 'none',
|
|
85
|
+
observedChannel: 'none',
|
|
86
|
+
// The shape of the cascade is how the bundler emits specifiers. Breaking the hub is a line of
|
|
87
|
+
// configuration, and one with a real cost on the other side, so it is never prescribed.
|
|
88
|
+
cascadeShape: 'config',
|
|
89
|
+
assetOrigin: 'config',
|
|
90
|
+
// Turning a framework's prefetching down is a setting, and on a large route table it is the
|
|
91
|
+
// difference between the first visit costing one screen and costing all of them.
|
|
92
|
+
prefetched: 'config',
|
|
93
|
+
zoneless: 'none',
|
|
94
|
+
theirs: 'none',
|
|
95
|
+
// A leaked credential is not a saving and not a refactor: it is an incident, and putting it in
|
|
96
|
+
// a list ordered by kilobytes would be a category mistake. It leads the report by severity.
|
|
97
|
+
secrets: 'none',
|
|
98
|
+
thirdParty: 'none',
|
|
99
|
+
licences: 'none',
|
|
100
|
+
transitive: 'none',
|
|
101
|
+
updateWeight: 'none',
|
|
102
|
+
bootGrew: 'none',
|
|
103
|
+
bootNewPackages: 'none',
|
|
104
|
+
sharedGrew: 'none',
|
|
105
|
+
signalsChanged: 'none',
|
|
106
|
+
screensGrew: 'none',
|
|
107
|
+
measuredExtra: 'none',
|
|
108
|
+
measuredShort: 'none',
|
|
109
|
+
measuredMatch: 'none',
|
|
110
|
+
// What a team answered about itself. There is nothing to do about an answer — it is the frame
|
|
111
|
+
// the rest is read through — with one exception that is still not a task: the card naming the
|
|
112
|
+
// questions nobody has answered. Its fix is to go and answer them, which takes a minute and no
|
|
113
|
+
// code, and calling that `config` would put "answer a question" in a list ordered by kilobytes.
|
|
114
|
+
situationAsked: 'none',
|
|
115
|
+
situationPriority: 'none',
|
|
116
|
+
situationMissing: 'none',
|
|
117
|
+
};
|