@jam-overture/loom 0.1.0 → 0.2.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/README.md +3 -1
- package/dist/application/application.d.ts +109 -0
- package/dist/application/application.js +97 -0
- package/dist/application/memory.d.ts +20 -0
- package/dist/application/memory.js +79 -0
- package/dist/application/store.d.ts +101 -0
- package/dist/application/store.js +25 -0
- package/dist/audience/audience.d.ts +36 -0
- package/dist/audience/audience.js +41 -0
- package/dist/cli/templates.js +19 -0
- package/dist/data/plan.js +0 -0
- package/dist/data/resolution.d.ts +23 -1
- package/dist/data/resolve.d.ts +30 -3
- package/dist/data/resolve.js +11 -3
- package/dist/ids.d.ts +10 -0
- package/dist/ids.js +11 -1
- package/dist/index.d.ts +1 -0
- package/dist/index.js +1 -0
- package/dist/patch.d.ts +54 -0
- package/dist/patch.js +44 -0
- package/dist/project/closing.d.ts +51 -0
- package/dist/project/closing.js +53 -0
- package/dist/project/memory.d.ts +20 -0
- package/dist/project/memory.js +97 -0
- package/dist/project/project.d.ts +90 -0
- package/dist/project/project.js +91 -0
- package/dist/project/store.d.ts +135 -0
- package/dist/project/store.js +41 -0
- package/dist/registered.d.ts +64 -0
- package/dist/registered.js +118 -0
- package/dist/render/behaviour-adjust.d.ts +11 -19
- package/dist/render/behaviour-adjust.js +75 -21
- package/dist/render/behaviour-present.d.ts +8 -0
- package/dist/render/behaviour-present.js +57 -6
- package/dist/render/behaviour.d.ts +98 -17
- package/dist/render/behaviour.js +91 -26
- package/dist/render/control-name.d.ts +68 -0
- package/dist/render/control-name.js +37 -0
- package/dist/render/diagnostics.d.ts +72 -0
- package/dist/render/diagnostics.js +7 -0
- package/dist/render/index.d.ts +2 -0
- package/dist/render/index.js +2 -0
- package/dist/render/reads.d.ts +11 -0
- package/dist/render/reads.js +12 -1
- package/dist/render/render.js +102 -7
- package/dist/render/slots.d.ts +52 -0
- package/dist/render/slots.js +24 -0
- package/dist/render/theme.d.ts +54 -1
- package/dist/render/theme.js +23 -1
- package/dist/render/unshown.d.ts +152 -0
- package/dist/render/unshown.js +80 -0
- package/dist/runtime/analysis.d.ts +94 -9
- package/dist/runtime/analysis.js +54 -9
- package/dist/runtime/assessment.d.ts +36 -2
- package/dist/runtime/assessment.js +27 -2
- package/dist/runtime/checks.d.ts +148 -0
- package/dist/runtime/checks.js +112 -0
- package/dist/runtime/disposition.d.ts +96 -0
- package/dist/runtime/disposition.js +46 -0
- package/dist/runtime/gate.js +22 -0
- package/dist/runtime/index.d.ts +3 -0
- package/dist/runtime/index.js +3 -0
- package/dist/runtime/irreversibility.d.ts +64 -0
- package/dist/runtime/irreversibility.js +45 -0
- package/dist/runtime/pipeline.d.ts +43 -0
- package/dist/runtime/pipeline.js +10 -2
- package/dist/runtime/policy-change.d.ts +93 -0
- package/dist/runtime/policy-change.js +299 -0
- package/dist/runtime/policy-log.d.ts +406 -0
- package/dist/runtime/policy-log.js +285 -0
- package/dist/runtime/reversibility.d.ts +11 -9
- package/dist/runtime/stakes.d.ts +129 -1
- package/dist/runtime/stakes.js +240 -26
- package/dist/runtime/vocabulary.d.ts +164 -7
- package/dist/runtime/vocabulary.js +181 -8
- package/dist/sdk/audit.d.ts +174 -3
- package/dist/sdk/audit.js +176 -17
- package/dist/sdk/catalogue.d.ts +9 -1
- package/dist/sdk/conformance.d.ts +37 -3
- package/dist/sdk/conformance.js +25 -4
- package/dist/sdk/definition.d.ts +65 -0
- package/dist/sdk/definition.js +22 -0
- package/dist/sdk/registry.d.ts +29 -2
- package/dist/sdk/registry.js +63 -1
- package/dist/signals/action-change.d.ts +507 -0
- package/dist/signals/action-change.js +265 -0
- package/dist/signals/action.d.ts +331 -0
- package/dist/signals/action.js +182 -0
- package/dist/signals/applied-window.contract.d.ts +23 -0
- package/dist/signals/applied-window.contract.js +160 -0
- package/dist/signals/arriving.d.ts +210 -0
- package/dist/signals/arriving.js +133 -0
- package/dist/signals/audiences.d.ts +528 -0
- package/dist/signals/audiences.js +255 -0
- package/dist/signals/broadcast.d.ts +8 -2
- package/dist/signals/broadcast.js +58 -8
- package/dist/signals/change.d.ts +378 -0
- package/dist/signals/change.js +327 -0
- package/dist/signals/collect.d.ts +41 -0
- package/dist/signals/collect.js +88 -7
- package/dist/signals/copy-change.d.ts +553 -0
- package/dist/signals/copy-change.js +377 -0
- package/dist/signals/copy.d.ts +337 -0
- package/dist/signals/copy.js +211 -0
- package/dist/signals/counters.d.ts +46 -0
- package/dist/signals/counters.js +102 -0
- package/dist/signals/deliver.d.ts +23 -4
- package/dist/signals/deliver.js +34 -6
- package/dist/signals/deployment-change.d.ts +371 -0
- package/dist/signals/deployment-change.js +268 -0
- package/dist/signals/deployment.d.ts +265 -0
- package/dist/signals/deployment.js +152 -0
- package/dist/signals/door.d.ts +92 -0
- package/dist/signals/door.js +53 -0
- package/dist/signals/fold.d.ts +10 -0
- package/dist/signals/fold.js +5 -1
- package/dist/signals/form-action.d.ts +302 -0
- package/dist/signals/form-action.js +169 -0
- package/dist/signals/form-copy.d.ts +523 -0
- package/dist/signals/form-copy.js +346 -0
- package/dist/signals/forms.d.ts +247 -0
- package/dist/signals/forms.js +147 -0
- package/dist/signals/funnel-change.d.ts +548 -0
- package/dist/signals/funnel-change.js +361 -0
- package/dist/signals/funnel.d.ts +532 -0
- package/dist/signals/funnel.js +216 -0
- package/dist/signals/health.d.ts +497 -0
- package/dist/signals/health.js +361 -0
- package/dist/signals/index.d.ts +41 -0
- package/dist/signals/index.js +41 -0
- package/dist/signals/ingest.d.ts +56 -1
- package/dist/signals/ingest.js +91 -1
- package/dist/signals/journal.d.ts +11 -0
- package/dist/signals/kinds.d.ts +8 -6
- package/dist/signals/kinds.js +14 -6
- package/dist/signals/library-action.d.ts +430 -0
- package/dist/signals/library-action.js +336 -0
- package/dist/signals/library-change.d.ts +477 -0
- package/dist/signals/library-change.js +335 -0
- package/dist/signals/library-copy-change.d.ts +498 -0
- package/dist/signals/library-copy-change.js +476 -0
- package/dist/signals/library-pace.d.ts +319 -0
- package/dist/signals/library-pace.js +305 -0
- package/dist/signals/library-reach-change.d.ts +636 -0
- package/dist/signals/library-reach-change.js +534 -0
- package/dist/signals/library-reach.d.ts +377 -0
- package/dist/signals/library-reach.js +227 -0
- package/dist/signals/library-word-reach-change.d.ts +567 -0
- package/dist/signals/library-word-reach-change.js +568 -0
- package/dist/signals/library.d.ts +306 -0
- package/dist/signals/library.js +178 -0
- package/dist/signals/memory.d.ts +9 -0
- package/dist/signals/memory.js +105 -14
- package/dist/signals/migrate.d.ts +17 -2
- package/dist/signals/migrate.js +122 -5
- package/dist/signals/notice.d.ts +334 -0
- package/dist/signals/notice.js +228 -0
- package/dist/signals/pace-change.d.ts +501 -0
- package/dist/signals/pace-change.js +310 -0
- package/dist/signals/pace.d.ts +296 -0
- package/dist/signals/pace.js +291 -0
- package/dist/signals/page-views.d.ts +365 -0
- package/dist/signals/page-views.js +218 -0
- package/dist/signals/parts.d.ts +344 -0
- package/dist/signals/parts.js +273 -0
- package/dist/signals/postgres.d.ts +16 -2
- package/dist/signals/postgres.js +390 -87
- package/dist/signals/progress.d.ts +212 -0
- package/dist/signals/progress.js +150 -0
- package/dist/signals/ratios.d.ts +108 -0
- package/dist/signals/ratios.js +40 -0
- package/dist/signals/reach.d.ts +309 -0
- package/dist/signals/reach.js +93 -0
- package/dist/signals/readable.d.ts +34 -0
- package/dist/signals/readable.js +34 -0
- package/dist/signals/readership.d.ts +381 -0
- package/dist/signals/readership.js +308 -0
- package/dist/signals/region-pages.d.ts +173 -0
- package/dist/signals/region-pages.js +62 -0
- package/dist/signals/region.d.ts +287 -0
- package/dist/signals/region.js +198 -0
- package/dist/signals/retention.d.ts +141 -0
- package/dist/signals/retention.js +58 -0
- package/dist/signals/rollup.d.ts +67 -3
- package/dist/signals/rollup.js +0 -0
- package/dist/signals/schema.d.ts +432 -1
- package/dist/signals/schema.js +157 -3
- package/dist/signals/signal.d.ts +237 -11
- package/dist/signals/signal.js +70 -10
- package/dist/signals/silence-census.d.ts +205 -0
- package/dist/signals/silence-census.js +87 -0
- package/dist/signals/silences.d.ts +848 -0
- package/dist/signals/silences.js +753 -0
- package/dist/signals/tally.d.ts +140 -11
- package/dist/signals/window-figures.d.ts +148 -0
- package/dist/signals/window-figures.js +42 -0
- package/dist/signals/window.d.ts +866 -0
- package/dist/signals/window.js +693 -0
- package/dist/signals/words.d.ts +24 -0
- package/dist/signals/words.js +24 -0
- package/dist/store/index.d.ts +19 -0
- package/dist/store/index.js +19 -0
- package/dist/store/memory.d.ts +2 -1
- package/dist/store/memory.js +48 -12
- package/dist/store/migrate.d.ts +80 -0
- package/dist/store/migrate.js +259 -7
- package/dist/store/postgres-applications.d.ts +4 -0
- package/dist/store/postgres-applications.js +197 -0
- package/dist/store/postgres-holds.d.ts +10 -1
- package/dist/store/postgres-holds.js +116 -101
- package/dist/store/postgres-policy-log.d.ts +14 -0
- package/dist/store/postgres-policy-log.js +240 -0
- package/dist/store/postgres-projects.d.ts +4 -0
- package/dist/store/postgres-projects.js +217 -0
- package/dist/store/postgres.d.ts +16 -1
- package/dist/store/postgres.js +59 -9
- package/dist/store/replay.d.ts +102 -1
- package/dist/store/replay.js +190 -19
- package/dist/store/reseed.d.ts +238 -0
- package/dist/store/reseed.js +308 -0
- package/dist/store/schema.d.ts +450 -2
- package/dist/store/schema.js +141 -5
- package/dist/store/store.d.ts +29 -6
- package/dist/submit/resolve.js +2 -1
- package/dist/telemetry/calibration.d.ts +25 -0
- package/dist/telemetry/calibration.js +27 -1
- package/dist/telemetry/event.d.ts +391 -33
- package/dist/telemetry/event.js +84 -20
- package/dist/telemetry/index.d.ts +1 -0
- package/dist/telemetry/index.js +1 -0
- package/dist/telemetry/journal.d.ts +72 -3
- package/dist/telemetry/journal.js +9 -0
- package/dist/telemetry/lookup.d.ts +27 -0
- package/dist/telemetry/lookup.js +18 -0
- package/dist/telemetry/memory.js +23 -0
- package/dist/telemetry/migrate.js +22 -1
- package/dist/telemetry/postgres.d.ts +10 -1
- package/dist/telemetry/postgres.js +172 -90
- package/dist/telemetry/remeasure.d.ts +78 -0
- package/dist/telemetry/remeasure.js +83 -0
- package/dist/telemetry/retention.d.ts +2 -2
- package/dist/telemetry/schema.d.ts +17 -0
- package/dist/telemetry/schema.js +27 -1
- package/dist/telemetry/sink.d.ts +2 -2
- package/dist/testing/application-contract.d.ts +14 -0
- package/dist/testing/application-contract.js +270 -0
- package/dist/testing/contracts.d.ts +12 -7
- package/dist/testing/contracts.js +12 -7
- package/dist/testing/definitions.d.ts +78 -0
- package/dist/testing/definitions.js +134 -9
- package/dist/testing/doubles.d.ts +103 -0
- package/dist/testing/doubles.js +143 -0
- package/dist/testing/index.d.ts +2 -2
- package/dist/testing/index.js +2 -2
- package/dist/testing/journal-contract.js +140 -2
- package/dist/testing/model-contract.d.ts +110 -0
- package/dist/testing/model-contract.js +150 -0
- package/dist/testing/policy-log-contract.d.ts +26 -0
- package/dist/testing/policy-log-contract.js +344 -0
- package/dist/testing/project-contract.d.ts +14 -0
- package/dist/testing/project-contract.js +266 -0
- package/dist/testing/reader-signal-contract.d.ts +27 -2
- package/dist/testing/reader-signal-contract.js +475 -5
- package/dist/testing/store-contract.d.ts +7 -1
- package/dist/testing/store-contract.js +84 -3
- package/dist/theme/apply.d.ts +20 -1
- package/dist/theme/apply.js +5 -3
- package/dist/theme/derive.d.ts +22 -0
- package/dist/theme/derive.js +54 -1
- package/dist/theme/library.js +1 -1
- package/dist/theme/measure.d.ts +34 -0
- package/dist/theme/measure.js +30 -1
- package/dist/theme/palettes.js +7 -7
- package/dist/theme/ramp.d.ts +64 -0
- package/dist/theme/ramp.js +114 -0
- package/dist/theme/registry.d.ts +9 -0
- package/dist/theme/registry.js +11 -1
- package/dist/theme/separation.d.ts +97 -3
- package/dist/theme/separation.js +75 -0
- package/dist/tree/compare.d.ts +9 -0
- package/dist/tree/compare.js +18 -0
- package/dist/write/computed.d.ts +60 -0
- package/dist/write/computed.js +61 -0
- package/dist/write/held.d.ts +59 -0
- package/dist/write/index.d.ts +5 -2
- package/dist/write/index.js +5 -2
- package/dist/write/reseed.d.ts +151 -0
- package/dist/write/reseed.js +184 -0
- package/dist/write/revert.js +2 -16
- package/package.json +98 -19
|
@@ -0,0 +1,306 @@
|
|
|
1
|
+
import type { PrimitiveType } from "../primitive-type.js";
|
|
2
|
+
import { type PrimitiveRole } from "../role.js";
|
|
3
|
+
import { type PageReading, type PartStanding } from "./parts.js";
|
|
4
|
+
/**
|
|
5
|
+
* Whether a *kind* of part gets read, across every page it is on.
|
|
6
|
+
*
|
|
7
|
+
* Every reading in this subsystem answers about one page: where its reading
|
|
8
|
+
* stops, how much of what it says gets read, what a change did to it.
|
|
9
|
+
* [`deployment.ts`](deployment.ts) is the first that is larger than a page, and
|
|
10
|
+
* it is still an order **over** pages — the unit it ranks is a page and the
|
|
11
|
+
* answer it gives is *fix this one next*.
|
|
12
|
+
*
|
|
13
|
+
* **Nothing could be asked about a kind of part.** A deployment builds forty
|
|
14
|
+
* pages out of the same two dozen primitives, and *do readers read the
|
|
15
|
+
* testimonial band anywhere* is a question about the **library** rather than
|
|
16
|
+
* about any one page. It is the question a model proposing a change most wants
|
|
17
|
+
* answered before it proposes one, and it was the one question the counters
|
|
18
|
+
* could not be asked: a type's placements are scattered across forty readings
|
|
19
|
+
* and nothing joined them.
|
|
20
|
+
*
|
|
21
|
+
* This is that join, taken off the readings a deployment already has and
|
|
22
|
+
* nothing else: no payload, no browser change, no counter that does not exist,
|
|
23
|
+
* no column and no byte on any wire. It is the **fourteenth** thing derived
|
|
24
|
+
* from what the server already knows rather than collected.
|
|
25
|
+
*
|
|
26
|
+
* ## The unit is the placement, and a reader is never the unit
|
|
27
|
+
*
|
|
28
|
+
* A page is a part of a revision of a tree; a **placement** is one element node
|
|
29
|
+
* of one revision, which is exactly what a `PartReading` is. So a type's row
|
|
30
|
+
* counts placements: *`loom.testimonial` stands in nine places and readers
|
|
31
|
+
* reached two of them.*
|
|
32
|
+
*
|
|
33
|
+
* **Everything that counts readers is absent from these rows**, and the reason
|
|
34
|
+
* is not caution. `views`, `reached` and `engaged` count distinct page views, and
|
|
35
|
+
* distinctness cannot be added — one reader who read a heading on three pages is
|
|
36
|
+
* three in a sum of `reached` and one person
|
|
37
|
+
* ([0147](../../decisions/0147-a-rollup-is-added-to-what-is-stored-and-a-distinct-view-count-is-therefore-approximate.md)).
|
|
38
|
+
* A `RoleReading` already refuses them one level down for the same reason
|
|
39
|
+
* ([0212](../../decisions/0212-what-a-reader-signal-means-is-joined-to-the-tree-when-it-is-read.md)),
|
|
40
|
+
* and across pages it is worse rather than better: each page's distinct counts
|
|
41
|
+
* are inflated by **its own** straddle rate, which is the fact that put every
|
|
42
|
+
* page's loss on the door's scale before it could be ranked
|
|
43
|
+
* ([0250](../../decisions/0250-a-deployment-is-ordered-by-readers-lost-at-the-doors-scale-and-a-page-the-door-cannot-scale-is-out-of-the-order.md)).
|
|
44
|
+
*
|
|
45
|
+
* A share of **placements** has none of that in it. `read ÷ (read + skipped)` is
|
|
46
|
+
* a ratio of two counts of parts of trees, so no reader is counted at all, no
|
|
47
|
+
* rollup window appears in either term, and shortening a deployment's window
|
|
48
|
+
* cannot move it. That is what makes it the figure this reading leads with.
|
|
49
|
+
*
|
|
50
|
+
* ## What that costs, said plainly
|
|
51
|
+
*
|
|
52
|
+
* **A placement on a page nine thousand people read counts the same as one on a
|
|
53
|
+
* page three people read.** A kind read in the one busy place and skipped in
|
|
54
|
+
* nine quiet ones reports a read share of one in ten, and *most readers who met
|
|
55
|
+
* it read it* would also have been true. The share is about places and never
|
|
56
|
+
* about people, and a surface that prints it as *readers skip this* is printing
|
|
57
|
+
* something this reading did not say.
|
|
58
|
+
*
|
|
59
|
+
* **The weighted figure is a different question and needs the door.** Weighting
|
|
60
|
+
* each placement by its page's readers means `reached ÷ views` per placement and
|
|
61
|
+
* a mean over them — two distinct counts, each inflated by its own page's
|
|
62
|
+
* straddle, so the pages whose readers linger would weigh most and a deployment
|
|
63
|
+
* that shortened its rollup window would see the figure move with no reader
|
|
64
|
+
* moving. The correction exists and is `opened` at the door (0250), so the
|
|
65
|
+
* question is answerable and is not answered here; it is filed rather than
|
|
66
|
+
* shipped with a caveat.
|
|
67
|
+
*
|
|
68
|
+
* **A share of placements multiplied by anything is not a count of people.** A
|
|
69
|
+
* share of one part of a page times the page's readership was a count of people
|
|
70
|
+
* larger than the page had, found on a reader card on 8 October; a share of
|
|
71
|
+
* places times a readership is worse, because its denominator is not people in
|
|
72
|
+
* the first place.
|
|
73
|
+
*
|
|
74
|
+
* ## Why a count of places is worth having anyway
|
|
75
|
+
*
|
|
76
|
+
* Because the three sentences it supports are the ones an author can act on, and
|
|
77
|
+
* none of them needs a reader to be counted:
|
|
78
|
+
*
|
|
79
|
+
* - *this kind of part is skipped in seven of the nine places it stands* — a
|
|
80
|
+
* fact about the library, which is a reason to change the primitive rather
|
|
81
|
+
* than the page;
|
|
82
|
+
* - *this kind says four thousand words and readers reached three hundred of
|
|
83
|
+
* them* — words partition a page exactly once (0212), so they add across
|
|
84
|
+
* placements without counting a sentence twice;
|
|
85
|
+
* - *this kind was used eleven hundred times* — an occurrence, filed against the
|
|
86
|
+
* part the reader used, so no press is counted twice (0167).
|
|
87
|
+
*
|
|
88
|
+
* ## The one figure that nests, and the total this does not publish
|
|
89
|
+
*
|
|
90
|
+
* `dwellMs` is time on screen, and a part is on screen while its children are.
|
|
91
|
+
* So one second a reader spent in a band is in the band's row **and** in the
|
|
92
|
+
* row of everything inside it, and that is true of a `RoleReading`'s dwell
|
|
93
|
+
* already. Within a kind it is a volume of attention and is useful as one; added
|
|
94
|
+
* **across** kinds it is not a duration anybody spent, so there is no
|
|
95
|
+
* reading-wide dwell here and there will not be one.
|
|
96
|
+
*
|
|
97
|
+
* Nor is there a deployment-wide `placements` share or a single headline number
|
|
98
|
+
* over the kinds. The artefact is a census, and the only error available to a
|
|
99
|
+
* census is counting the same page twice — which is the one thing deduplicated
|
|
100
|
+
* here (0158: counting a window and forgetting it are one operation).
|
|
101
|
+
*
|
|
102
|
+
* Pure. It reaches no store, no clock and no DOM, it is linear in the parts of
|
|
103
|
+
* the readings handed to it, and nothing in it survives into a browser bundle.
|
|
104
|
+
*/
|
|
105
|
+
/** Why a kind's read share is not there. */
|
|
106
|
+
export type KindSilence =
|
|
107
|
+
/**
|
|
108
|
+
* No placement of it has a verdict: every page it stands on held no views, or
|
|
109
|
+
* reported something other than a view of it.
|
|
110
|
+
*
|
|
111
|
+
* Not *nobody read it*. A placement whose standing is `unknown` is in a window
|
|
112
|
+
* that said nothing, and the one direction a census of a quiet deployment must
|
|
113
|
+
* not be wrong in is calling that a skip (0212). The placements are still counted and still in {@link KindReading.standings};
|
|
114
|
+
* what is withheld is the share, because its denominator would be nought.
|
|
115
|
+
*/
|
|
116
|
+
"unread"
|
|
117
|
+
/**
|
|
118
|
+
* Nothing in the pages read is of this kind at all.
|
|
119
|
+
*
|
|
120
|
+
* Only ever a role row, and it is the reason a role row exists for every
|
|
121
|
+
* member of the vocabulary: *nothing in this library is a heading* is a fact
|
|
122
|
+
* about the library, and a surface that had to tell a missing row from an
|
|
123
|
+
* empty one would be reading the vocabulary itself. A type row cannot be in
|
|
124
|
+
* this state, because a type row exists only where a part of that type stands.
|
|
125
|
+
*
|
|
126
|
+
* Kept apart from {@link KindSilence} `unread` because the two are opposite
|
|
127
|
+
* instructions: one says measure more, the other says there is nothing here to
|
|
128
|
+
* measure.
|
|
129
|
+
*/
|
|
130
|
+
| "unplaced";
|
|
131
|
+
export declare const KIND_SILENCES: readonly KindSilence[];
|
|
132
|
+
/** One line per silence, for a surface saying why a kind has no share. */
|
|
133
|
+
export declare const describeKindSilence: (silence: KindSilence) => string;
|
|
134
|
+
/** What a row is a census of: one primitive type, or one role, across the pages read. */
|
|
135
|
+
export type KindKey = {
|
|
136
|
+
readonly by: "type";
|
|
137
|
+
readonly type: PrimitiveType;
|
|
138
|
+
}
|
|
139
|
+
/** `null` is the row for parts whose type declared no role, which is most of a library today. */
|
|
140
|
+
| {
|
|
141
|
+
readonly by: "role";
|
|
142
|
+
readonly role: PrimitiveRole | null;
|
|
143
|
+
};
|
|
144
|
+
/** A key as a string, for a surface keying a list and for this module's own grouping. */
|
|
145
|
+
export declare const kindKeyOf: (kind: KindKey) => string;
|
|
146
|
+
/**
|
|
147
|
+
* One kind of part, everywhere it stands in the pages read.
|
|
148
|
+
*
|
|
149
|
+
* The same shape for a type row and a role row, because they are one census
|
|
150
|
+
* asked of two keys: a type is what an author can change and a role is what a
|
|
151
|
+
* reader meets, and a figure that meant different things in the two would be the
|
|
152
|
+
* kind of near-duplicate this subsystem has already been bitten by.
|
|
153
|
+
*/
|
|
154
|
+
export type KindReading = {
|
|
155
|
+
readonly kind: KindKey;
|
|
156
|
+
/** What part a type plays (0114), or `null`. Always `null` on a role row, which carries it as its key. */
|
|
157
|
+
readonly role: PrimitiveRole | null;
|
|
158
|
+
/** Element nodes of this kind across the readings. */
|
|
159
|
+
readonly placements: number;
|
|
160
|
+
/** Distinct trees it stands in, which is not the number of placements and not the number of readings. */
|
|
161
|
+
readonly trees: number;
|
|
162
|
+
/** Distinct revisions it stands in: two live revisions of one page are two. */
|
|
163
|
+
readonly revisions: number;
|
|
164
|
+
/** Placements by standing. The three add to {@link placements}. */
|
|
165
|
+
readonly standings: Readonly<Record<PartStanding, number>>;
|
|
166
|
+
/**
|
|
167
|
+
* The share of its placements at least one reader reached. `null` where
|
|
168
|
+
* {@link silence} says why not.
|
|
169
|
+
*
|
|
170
|
+
* *At least one*, which is what a standing of `read` means and not what a
|
|
171
|
+
* person reads the word as (0235). `read ÷ (read + skipped)`, so a placement
|
|
172
|
+
* nothing can be said about is in neither term rather than counted as a skip.
|
|
173
|
+
*
|
|
174
|
+
* **Places and not people.** See the module documentation: it is sound as a
|
|
175
|
+
* statement about where this kind of part stands and is not a share of
|
|
176
|
+
* readers.
|
|
177
|
+
*/
|
|
178
|
+
readonly readShare: number | null;
|
|
179
|
+
/**
|
|
180
|
+
* Why {@link readShare} is not there, and `null` where it is.
|
|
181
|
+
*
|
|
182
|
+
* About the read share and not about the row: {@link wordShare} is absent for
|
|
183
|
+
* a reason of its own and says so where it is, which is how a copy reading
|
|
184
|
+
* already publishes a share beside a withheld figure (0235).
|
|
185
|
+
*/
|
|
186
|
+
readonly silence: KindSilence | null;
|
|
187
|
+
/**
|
|
188
|
+
* Every word this kind says across its placements, counted once.
|
|
189
|
+
*
|
|
190
|
+
* Addable for the reason no view count here is: a part's words are its own and
|
|
191
|
+
* the words of a page are partitioned across its parts exactly once (0212), so
|
|
192
|
+
* two placements' words are two different sentences.
|
|
193
|
+
*/
|
|
194
|
+
readonly words: number;
|
|
195
|
+
/** Words said by a placement at least one reader reached. */
|
|
196
|
+
readonly wordsReached: number;
|
|
197
|
+
/**
|
|
198
|
+
* {@link wordsReached} over {@link words}; `null` where this kind says nothing
|
|
199
|
+
* at all, which a spacer, a rule and a stack that only holds other parts all
|
|
200
|
+
* do.
|
|
201
|
+
*/
|
|
202
|
+
readonly wordShare: number | null;
|
|
203
|
+
/**
|
|
204
|
+
* Placements whose words are a floor, because the type declares no `copy`
|
|
205
|
+
* (0122).
|
|
206
|
+
*
|
|
207
|
+
* The direction {@link wordShare} is wrong in, handed over rather than
|
|
208
|
+
* summarised: a floored placement understates the numerator and the
|
|
209
|
+
* denominator together where it was reached, and the denominator alone where
|
|
210
|
+
* it was skipped. On a library built from the starter primitives this is
|
|
211
|
+
* nought (0223); on one built from a deployment's own it is most of the rows,
|
|
212
|
+
* and that is the thinness the server-side join already names rather than a
|
|
213
|
+
* fault here (0212).
|
|
214
|
+
*/
|
|
215
|
+
readonly floored: number;
|
|
216
|
+
/**
|
|
217
|
+
* Time on screen across its placements, added.
|
|
218
|
+
*
|
|
219
|
+
* A volume of attention and **not a duration anybody spent**: a part is on
|
|
220
|
+
* screen while its children are, so a nested placement's seconds are its
|
|
221
|
+
* ancestors' too. Comparable between two kinds of the same depth and
|
|
222
|
+
* meaningless added across kinds, which is why nothing here adds it.
|
|
223
|
+
*/
|
|
224
|
+
readonly dwellMs: number;
|
|
225
|
+
/** Presses, filed against the part the reader used, so no press is in two rows (0167). */
|
|
226
|
+
readonly activations: number;
|
|
227
|
+
readonly opens: number;
|
|
228
|
+
readonly closes: number;
|
|
229
|
+
/** Forms this kind of part let go (0211). */
|
|
230
|
+
readonly completions: number;
|
|
231
|
+
};
|
|
232
|
+
/** What a deployment's library does for its readers, by kind of part. */
|
|
233
|
+
export type LibraryReading = {
|
|
234
|
+
/**
|
|
235
|
+
* Every type that stands anywhere, most placements skipped first.
|
|
236
|
+
*
|
|
237
|
+
* Then the lower read share, then by type, so two kinds that are skipped
|
|
238
|
+
* equally often do not reorder on a refresh.
|
|
239
|
+
*/
|
|
240
|
+
readonly byType: readonly KindReading[];
|
|
241
|
+
/**
|
|
242
|
+
* Every role in the vocabulary that stands anywhere, then the row for parts
|
|
243
|
+
* whose type declared none, in the same order as {@link byType}.
|
|
244
|
+
*
|
|
245
|
+
* Thin today for the reason every role figure in this subsystem is thin:
|
|
246
|
+
* nothing in `src/primitives/` declares one, so nearly every part is in the
|
|
247
|
+
* `null` row. The join is at read time (0212), so the day a role is declared
|
|
248
|
+
* every counter already stored reinterprets and these rows start answering
|
|
249
|
+
* without a migration.
|
|
250
|
+
*/
|
|
251
|
+
readonly byRole: readonly KindReading[];
|
|
252
|
+
/** Readings counted, which is revisions of pages and not trees. */
|
|
253
|
+
readonly pages: number;
|
|
254
|
+
/** Distinct trees across them. */
|
|
255
|
+
readonly trees: number;
|
|
256
|
+
/** Element nodes across them, which is the sum of every type row's placements. */
|
|
257
|
+
readonly placements: number;
|
|
258
|
+
/** Placements by standing, over the whole library. */
|
|
259
|
+
readonly standings: Readonly<Record<PartStanding, number>>;
|
|
260
|
+
/**
|
|
261
|
+
* The type skipped in the most places, which is the kind to look at first.
|
|
262
|
+
*
|
|
263
|
+
* By the **count** of places and not by the share, for the reason a page's
|
|
264
|
+
* falls are ranked by the readers they lose (0221): a kind skipped in its one
|
|
265
|
+
* and only place is a perfect share and a smaller problem than one skipped in
|
|
266
|
+
* seven of nine. `null` where nothing anywhere was skipped — a healthy
|
|
267
|
+
* deployment and an unmeasured one both, which {@link standings} tells apart.
|
|
268
|
+
*
|
|
269
|
+
* A type and never a role, because a type is the thing an author can replace.
|
|
270
|
+
*/
|
|
271
|
+
readonly mostSkipped: KindReading | null;
|
|
272
|
+
/** The type used most, by presses. A count of things that happened, not of readers. */
|
|
273
|
+
readonly mostUsed: KindReading | null;
|
|
274
|
+
/**
|
|
275
|
+
* Readings of a revision beyond the first, which were dropped.
|
|
276
|
+
*
|
|
277
|
+
* A caller that concatenated two reads holds one page twice, and a page twice
|
|
278
|
+
* in a census is the one way a census can lie about how much of a library
|
|
279
|
+
* there is.
|
|
280
|
+
*/
|
|
281
|
+
readonly duplicated: number;
|
|
282
|
+
/**
|
|
283
|
+
* Types whose readings disagreed about the role they play, where the first
|
|
284
|
+
* reading's answer stands.
|
|
285
|
+
*
|
|
286
|
+
* The one failure this join can have that nothing else would catch: readings
|
|
287
|
+
* joined against two different registries, concatenated. A type plays one part
|
|
288
|
+
* (0114), so a disagreement is not a fact about the library — it is two
|
|
289
|
+
* libraries read as one, and every role row below is then about neither.
|
|
290
|
+
*/
|
|
291
|
+
readonly roleDisagreed: readonly PrimitiveType[];
|
|
292
|
+
};
|
|
293
|
+
/**
|
|
294
|
+
* Whether a kind of part gets read, across every page it stands on.
|
|
295
|
+
*
|
|
296
|
+
* Takes the readings rather than the counters and the trees, for the reason
|
|
297
|
+
* every derived reading in this subsystem does: the standings and the words are
|
|
298
|
+
* what this is made of, and deriving them twice is how two screens come to
|
|
299
|
+
* disagree. A caller with a window of counters reads each page, then this.
|
|
300
|
+
*
|
|
301
|
+
* Linear in the parts handed in, with one pass that fills both groupings: a pass
|
|
302
|
+
* per key would be a walk of the whole library per member of the role
|
|
303
|
+
* vocabulary, and the vocabulary grows while the library is what it is.
|
|
304
|
+
*/
|
|
305
|
+
export declare const libraryReadingOf: (readings: readonly PageReading[]) => LibraryReading;
|
|
306
|
+
//# sourceMappingURL=library.d.ts.map
|
|
@@ -0,0 +1,178 @@
|
|
|
1
|
+
import { everyMemberOf } from "../closed-set.js";
|
|
2
|
+
import { PRIMITIVE_ROLES } from "../role.js";
|
|
3
|
+
import { readingKeyOf } from "./audiences.js";
|
|
4
|
+
import { PART_STANDINGS } from "./parts.js";
|
|
5
|
+
import { countWords } from "./words.js";
|
|
6
|
+
export const KIND_SILENCES = everyMemberOf()([
|
|
7
|
+
"unread",
|
|
8
|
+
"unplaced",
|
|
9
|
+
]);
|
|
10
|
+
/** One line per silence, for a surface saying why a kind has no share. */
|
|
11
|
+
export const describeKindSilence = (silence) => {
|
|
12
|
+
switch (silence) {
|
|
13
|
+
case "unread":
|
|
14
|
+
return "nothing reported a view of any place this kind of part stands";
|
|
15
|
+
case "unplaced":
|
|
16
|
+
return "nothing in the pages read is of this kind";
|
|
17
|
+
}
|
|
18
|
+
};
|
|
19
|
+
/** A key as a string, for a surface keying a list and for this module's own grouping. */
|
|
20
|
+
export const kindKeyOf = (kind) => kind.by === "type" ? `type\u0000${kind.type}` : `role\u0000${kind.role ?? ""}`;
|
|
21
|
+
const NO_STANDINGS = Object.freeze(Object.fromEntries(PART_STANDINGS.map((standing) => [standing, 0])));
|
|
22
|
+
const tallying = (kind) => ({
|
|
23
|
+
kind,
|
|
24
|
+
role: null,
|
|
25
|
+
placements: 0,
|
|
26
|
+
trees: new Set(),
|
|
27
|
+
revisions: new Set(),
|
|
28
|
+
standings: { ...NO_STANDINGS },
|
|
29
|
+
words: 0,
|
|
30
|
+
wordsReached: 0,
|
|
31
|
+
floored: 0,
|
|
32
|
+
dwellMs: 0,
|
|
33
|
+
activations: 0,
|
|
34
|
+
opens: 0,
|
|
35
|
+
closes: 0,
|
|
36
|
+
completions: 0,
|
|
37
|
+
});
|
|
38
|
+
const add = (into, part, page, revision) => {
|
|
39
|
+
const words = countWords(part.copy.words);
|
|
40
|
+
into.placements += 1;
|
|
41
|
+
into.trees.add(page.treeId);
|
|
42
|
+
into.revisions.add(revision);
|
|
43
|
+
into.standings[part.standing] += 1;
|
|
44
|
+
into.words += words;
|
|
45
|
+
into.wordsReached += part.standing === "read" ? words : 0;
|
|
46
|
+
into.floored += part.copy.unread.length > 0 || part.copy.unspoken.length > 0 ? 1 : 0;
|
|
47
|
+
into.dwellMs += part.counters?.dwellMs ?? 0;
|
|
48
|
+
into.activations += part.counters?.activations ?? 0;
|
|
49
|
+
into.opens += part.counters?.opens ?? 0;
|
|
50
|
+
into.closes += part.counters?.closes ?? 0;
|
|
51
|
+
into.completions += part.counters?.completions ?? 0;
|
|
52
|
+
};
|
|
53
|
+
/**
|
|
54
|
+
* The silence, with the two reasons tried in the order they have to be tried in.
|
|
55
|
+
*
|
|
56
|
+
* Nothing of the kind before nothing measured, because *there is no such part in
|
|
57
|
+
* this library* is a better answer than *nobody was seen reading it*, and the
|
|
58
|
+
* second is true of the first by accident.
|
|
59
|
+
*/
|
|
60
|
+
const silenceOf = (of, verdicts) => {
|
|
61
|
+
if (of.placements === 0)
|
|
62
|
+
return "unplaced";
|
|
63
|
+
return verdicts === 0 ? "unread" : null;
|
|
64
|
+
};
|
|
65
|
+
const rowOf = (of) => {
|
|
66
|
+
const verdicts = of.standings.read + of.standings.skipped;
|
|
67
|
+
return {
|
|
68
|
+
kind: of.kind,
|
|
69
|
+
role: of.kind.by === "type" ? of.role : null,
|
|
70
|
+
placements: of.placements,
|
|
71
|
+
trees: of.trees.size,
|
|
72
|
+
revisions: of.revisions.size,
|
|
73
|
+
standings: { ...of.standings },
|
|
74
|
+
readShare: verdicts === 0 ? null : of.standings.read / verdicts,
|
|
75
|
+
silence: silenceOf(of, verdicts),
|
|
76
|
+
words: of.words,
|
|
77
|
+
wordsReached: of.wordsReached,
|
|
78
|
+
wordShare: of.words === 0 ? null : of.wordsReached / of.words,
|
|
79
|
+
floored: of.floored,
|
|
80
|
+
dwellMs: of.dwellMs,
|
|
81
|
+
activations: of.activations,
|
|
82
|
+
opens: of.opens,
|
|
83
|
+
closes: of.closes,
|
|
84
|
+
completions: of.completions,
|
|
85
|
+
};
|
|
86
|
+
};
|
|
87
|
+
/** The name a row is ordered by, which is the key's own and never the row's position. */
|
|
88
|
+
const nameOf = (kind) => (kind.by === "type" ? kind.type : (kind.role ?? ""));
|
|
89
|
+
/**
|
|
90
|
+
* The kind to look at first, which is the ranking rule spelled once.
|
|
91
|
+
*
|
|
92
|
+
* Most places skipped, then the lower read share, then by name — so a kind with
|
|
93
|
+
* no share at all sorts after one with a share of nought rather than above it,
|
|
94
|
+
* because `null` is *nothing can be said* and not *nobody read it*.
|
|
95
|
+
*/
|
|
96
|
+
const worseOf = (one, other) => other.standings.skipped - one.standings.skipped ||
|
|
97
|
+
(one.readShare ?? 2) - (other.readShare ?? 2) ||
|
|
98
|
+
nameOf(one.kind).localeCompare(nameOf(other.kind));
|
|
99
|
+
/**
|
|
100
|
+
* Whether a kind of part gets read, across every page it stands on.
|
|
101
|
+
*
|
|
102
|
+
* Takes the readings rather than the counters and the trees, for the reason
|
|
103
|
+
* every derived reading in this subsystem does: the standings and the words are
|
|
104
|
+
* what this is made of, and deriving them twice is how two screens come to
|
|
105
|
+
* disagree. A caller with a window of counters reads each page, then this.
|
|
106
|
+
*
|
|
107
|
+
* Linear in the parts handed in, with one pass that fills both groupings: a pass
|
|
108
|
+
* per key would be a walk of the whole library per member of the role
|
|
109
|
+
* vocabulary, and the vocabulary grows while the library is what it is.
|
|
110
|
+
*/
|
|
111
|
+
export const libraryReadingOf = (readings) => {
|
|
112
|
+
const rows = new Map();
|
|
113
|
+
const seen = new Set();
|
|
114
|
+
const trees = new Set();
|
|
115
|
+
const standings = { ...NO_STANDINGS };
|
|
116
|
+
const disagreed = new Set();
|
|
117
|
+
let pages = 0;
|
|
118
|
+
let duplicated = 0;
|
|
119
|
+
let placements = 0;
|
|
120
|
+
/**
|
|
121
|
+
* Every role in the vocabulary gets a row whether or not anything plays it,
|
|
122
|
+
* the way a page's role rows do — a role nothing in the library plays is a
|
|
123
|
+
* fact about the library worth having, and a surface that had to tell a
|
|
124
|
+
* missing row from an empty one would be reading the vocabulary itself.
|
|
125
|
+
*/
|
|
126
|
+
for (const role of [...PRIMITIVE_ROLES, null]) {
|
|
127
|
+
const kind = { by: "role", role };
|
|
128
|
+
rows.set(kindKeyOf(kind), tallying(kind));
|
|
129
|
+
}
|
|
130
|
+
for (const reading of readings) {
|
|
131
|
+
const revision = readingKeyOf(reading);
|
|
132
|
+
if (seen.has(revision)) {
|
|
133
|
+
duplicated += 1;
|
|
134
|
+
continue;
|
|
135
|
+
}
|
|
136
|
+
seen.add(revision);
|
|
137
|
+
trees.add(reading.treeId);
|
|
138
|
+
pages += 1;
|
|
139
|
+
for (const part of reading.parts) {
|
|
140
|
+
const keys = [
|
|
141
|
+
{ by: "type", type: part.type },
|
|
142
|
+
{ by: "role", role: part.role },
|
|
143
|
+
];
|
|
144
|
+
placements += 1;
|
|
145
|
+
standings[part.standing] += 1;
|
|
146
|
+
for (const kind of keys) {
|
|
147
|
+
const key = kindKeyOf(kind);
|
|
148
|
+
const row = rows.get(key) ?? tallying(kind);
|
|
149
|
+
if (kind.by === "type") {
|
|
150
|
+
if (row.placements === 0)
|
|
151
|
+
row.role = part.role;
|
|
152
|
+
else if (row.role !== part.role)
|
|
153
|
+
disagreed.add(part.type);
|
|
154
|
+
}
|
|
155
|
+
add(row, part, reading, revision);
|
|
156
|
+
rows.set(key, row);
|
|
157
|
+
}
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
const built = [...rows.values()].map(rowOf);
|
|
161
|
+
const byType = built.filter((row) => row.kind.by === "type").sort(worseOf);
|
|
162
|
+
return {
|
|
163
|
+
byType,
|
|
164
|
+
byRole: built.filter((row) => row.kind.by === "role").sort(worseOf),
|
|
165
|
+
pages,
|
|
166
|
+
trees: trees.size,
|
|
167
|
+
placements,
|
|
168
|
+
standings,
|
|
169
|
+
mostSkipped: byType.find((row) => row.standings.skipped > 0) ?? null,
|
|
170
|
+
mostUsed: byType
|
|
171
|
+
.filter((row) => row.activations > 0)
|
|
172
|
+
.sort((one, other) => other.activations - one.activations ||
|
|
173
|
+
nameOf(one.kind).localeCompare(nameOf(other.kind)))[0] ?? null,
|
|
174
|
+
duplicated,
|
|
175
|
+
roleDisagreed: [...disagreed].sort((one, other) => one.localeCompare(other)),
|
|
176
|
+
};
|
|
177
|
+
};
|
|
178
|
+
//# sourceMappingURL=library.js.map
|
package/dist/signals/memory.d.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import { type Clock } from "../runtime/events.js";
|
|
2
2
|
import { type ReaderSignalJournal } from "./journal.js";
|
|
3
|
+
import type { ReaderRegionStore } from "./region.js";
|
|
3
4
|
import type { ReaderTallyStore } from "./tally.js";
|
|
4
5
|
/**
|
|
5
6
|
* The buffer and the counters, in the process.
|
|
@@ -14,4 +15,12 @@ import type { ReaderTallyStore } from "./tally.js";
|
|
|
14
15
|
*/
|
|
15
16
|
export declare const memoryReaderSignalJournal: (clock?: Clock) => ReaderSignalJournal;
|
|
16
17
|
export declare const memoryReaderTallyStore: () => ReaderTallyStore;
|
|
18
|
+
/**
|
|
19
|
+
* Where readers were, in the process.
|
|
20
|
+
*
|
|
21
|
+
* Additive like the tallies, and for a sharper reason: every call is one
|
|
22
|
+
* delivery's worth of arrivals, so a store that replaced would report the last
|
|
23
|
+
* reader rather than the readership.
|
|
24
|
+
*/
|
|
25
|
+
export declare const memoryReaderRegionStore: () => ReaderRegionStore;
|
|
17
26
|
//# sourceMappingURL=memory.d.ts.map
|
package/dist/signals/memory.js
CHANGED
|
@@ -1,7 +1,9 @@
|
|
|
1
|
+
import { DEFAULT_AUDIENCE_ID } from "../audience/audience.js";
|
|
1
2
|
import { cursorPosition, pageEnds } from "../paging.js";
|
|
2
3
|
import { ok } from "../result.js";
|
|
3
4
|
import { systemClock } from "../runtime/events.js";
|
|
4
5
|
import { clampReaderSignalLimit, } from "./journal.js";
|
|
6
|
+
import { funnelKey, inAudience, pageViewKey, regionKey, tallyKey } from "./counters.js";
|
|
5
7
|
/**
|
|
6
8
|
* The buffer and the counters, in the process.
|
|
7
9
|
*
|
|
@@ -16,10 +18,21 @@ import { clampReaderSignalLimit, } from "./journal.js";
|
|
|
16
18
|
export const memoryReaderSignalJournal = (clock = systemClock) => {
|
|
17
19
|
let batches = [];
|
|
18
20
|
let nextSeq = 1;
|
|
19
|
-
|
|
21
|
+
/**
|
|
22
|
+
* The opening marker is dropped rather than buffered.
|
|
23
|
+
*
|
|
24
|
+
* It says *a page view began with this delivery*, which is a fact the door
|
|
25
|
+
* uses and rollup has no question about — and a buffer is for what rollup
|
|
26
|
+
* reads. Postgres drops it by storing the columns it knows, so dropping it
|
|
27
|
+
* here is what keeps the two implementations the same buffer rather than two
|
|
28
|
+
* that happen to pass the same tests.
|
|
29
|
+
*/
|
|
30
|
+
const positioned = ({ first: _opening, ...batch }) => ({
|
|
20
31
|
...batch,
|
|
21
32
|
seq: nextSeq++,
|
|
22
33
|
receivedAt: clock.now(),
|
|
34
|
+
/** Resolved on the way in, as the Postgres buffer resolves it (0284). */
|
|
35
|
+
audienceId: batch.audience ?? DEFAULT_AUDIENCE_ID,
|
|
23
36
|
});
|
|
24
37
|
return {
|
|
25
38
|
receive: (received) => {
|
|
@@ -51,19 +64,49 @@ export const memoryReaderSignalJournal = (clock = systemClock) => {
|
|
|
51
64
|
},
|
|
52
65
|
};
|
|
53
66
|
};
|
|
54
|
-
const
|
|
55
|
-
|
|
56
|
-
const funnelKey = (answer) => `${answer.treeId} ${answer.revision} ${endOf(answer.pair.from)} ${endOf(answer.pair.to)}`;
|
|
57
|
-
const matches = (row, request) => (request?.treeId === undefined || row.treeId === request.treeId) &&
|
|
67
|
+
const matches = (row, request) => (request?.audience === undefined || row.audienceId === request.audience) &&
|
|
68
|
+
(request?.treeId === undefined || row.treeId === request.treeId) &&
|
|
58
69
|
(request?.revision === undefined || row.revision === request.revision);
|
|
59
70
|
export const memoryReaderTallyStore = () => {
|
|
60
71
|
const tallies = new Map();
|
|
61
72
|
const funnels = new Map();
|
|
62
|
-
const
|
|
63
|
-
|
|
73
|
+
const pageViews = new Map();
|
|
74
|
+
/**
|
|
75
|
+
* One row written from two sides, so the add is spelled once and told which
|
|
76
|
+
* column it is moving.
|
|
77
|
+
*
|
|
78
|
+
* A row created by either side starts the other column at nought, which is
|
|
79
|
+
* what it is: openings a rollup has not reached yet, or a window of batches
|
|
80
|
+
* whose opening went to an instance that has since gone away.
|
|
81
|
+
*
|
|
82
|
+
* **`foldedAt` is the one field only one of the two writers may touch**
|
|
83
|
+
* (0274). A fold stamps it; a door write carries forward whatever is there,
|
|
84
|
+
* including nothing — which is what makes it able to say that openings have
|
|
85
|
+
* been pending longer than a deployment's schedule allows, where `updatedAt`
|
|
86
|
+
* cannot.
|
|
87
|
+
*/
|
|
88
|
+
const addPageViews = (counts, counted, at, audience) => {
|
|
89
|
+
for (const count of counts) {
|
|
90
|
+
const key = inAudience(audience, pageViewKey(count));
|
|
91
|
+
const existing = pageViews.get(key);
|
|
92
|
+
const foldedAt = counted === "appearances" ? at : existing?.foldedAt;
|
|
93
|
+
pageViews.set(key, {
|
|
94
|
+
audienceId: audience,
|
|
95
|
+
treeId: count.treeId,
|
|
96
|
+
revision: count.revision,
|
|
97
|
+
opened: (existing?.opened ?? 0) + (counted === "opened" ? count.views : 0),
|
|
98
|
+
appearances: (existing?.appearances ?? 0) + (counted === "appearances" ? count.views : 0),
|
|
99
|
+
updatedAt: at,
|
|
100
|
+
...(foldedAt === undefined ? {} : { foldedAt }),
|
|
101
|
+
});
|
|
102
|
+
}
|
|
103
|
+
};
|
|
104
|
+
const addTally = (tally, at, audience) => {
|
|
105
|
+
const key = inAudience(audience, tallyKey(tally));
|
|
64
106
|
const existing = tallies.get(key);
|
|
65
107
|
tallies.set(key, {
|
|
66
108
|
...tally,
|
|
109
|
+
audienceId: audience,
|
|
67
110
|
views: (existing?.views ?? 0) + tally.views,
|
|
68
111
|
reached: (existing?.reached ?? 0) + tally.reached,
|
|
69
112
|
engaged: (existing?.engaged ?? 0) + tally.engaged,
|
|
@@ -71,29 +114,77 @@ export const memoryReaderTallyStore = () => {
|
|
|
71
114
|
activations: (existing?.activations ?? 0) + tally.activations,
|
|
72
115
|
opens: (existing?.opens ?? 0) + tally.opens,
|
|
73
116
|
closes: (existing?.closes ?? 0) + tally.closes,
|
|
117
|
+
completions: (existing?.completions ?? 0) + tally.completions,
|
|
74
118
|
updatedAt: at,
|
|
75
119
|
});
|
|
76
120
|
};
|
|
77
|
-
const addFunnel = (answer, at) => {
|
|
78
|
-
const key = funnelKey(answer);
|
|
121
|
+
const addFunnel = (answer, at, audience) => {
|
|
122
|
+
const key = inAudience(audience, funnelKey(answer));
|
|
79
123
|
const existing = funnels.get(key);
|
|
80
124
|
funnels.set(key, {
|
|
81
125
|
...answer,
|
|
126
|
+
audienceId: audience,
|
|
82
127
|
reached: (existing?.reached ?? 0) + answer.reached,
|
|
83
128
|
converted: (existing?.converted ?? 0) + answer.converted,
|
|
84
129
|
updatedAt: at,
|
|
85
130
|
});
|
|
86
131
|
};
|
|
132
|
+
/**
|
|
133
|
+
* Every audience in one go, which is the whole window (0316).
|
|
134
|
+
*
|
|
135
|
+
* Nothing here can fail, so there is no partial write to roll back and the
|
|
136
|
+
* atomicity `ReaderTallyStore.applyWindow` asks for is free. What the
|
|
137
|
+
* reference implementation is for is the *other* half of that contract: two
|
|
138
|
+
* entries naming one audience are added rather than refused, which is a
|
|
139
|
+
* property Postgres has to be written to have and this gets by construction.
|
|
140
|
+
*/
|
|
141
|
+
const applyWindow = (window, at) => {
|
|
142
|
+
for (const counters of window) {
|
|
143
|
+
const audience = counters.audience ?? DEFAULT_AUDIENCE_ID;
|
|
144
|
+
for (const tally of counters.tallies)
|
|
145
|
+
addTally(tally, at, audience);
|
|
146
|
+
for (const answer of counters.funnels)
|
|
147
|
+
addFunnel(answer, at, audience);
|
|
148
|
+
addPageViews(counters.appearances ?? [], "appearances", at, audience);
|
|
149
|
+
}
|
|
150
|
+
return Promise.resolve(ok(undefined));
|
|
151
|
+
};
|
|
87
152
|
return {
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
addFunnel(answer, at);
|
|
153
|
+
applyWindow,
|
|
154
|
+
apply: (counters, at, audience = DEFAULT_AUDIENCE_ID) => applyWindow([{ ...counters, audience }], at),
|
|
155
|
+
opened: (openings, at, audience = DEFAULT_AUDIENCE_ID) => {
|
|
156
|
+
addPageViews(openings, "opened", at, audience);
|
|
93
157
|
return Promise.resolve(ok(undefined));
|
|
94
158
|
},
|
|
95
159
|
tallies: (request) => Promise.resolve(ok([...tallies.values()].filter((row) => matches(row, request)))),
|
|
96
160
|
funnels: (request) => Promise.resolve(ok([...funnels.values()].filter((row) => matches(row, request)))),
|
|
161
|
+
pageViews: (request) => Promise.resolve(ok([...pageViews.values()].filter((row) => matches(row, request)))),
|
|
162
|
+
};
|
|
163
|
+
};
|
|
164
|
+
/**
|
|
165
|
+
* Where readers were, in the process.
|
|
166
|
+
*
|
|
167
|
+
* Additive like the tallies, and for a sharper reason: every call is one
|
|
168
|
+
* delivery's worth of arrivals, so a store that replaced would report the last
|
|
169
|
+
* reader rather than the readership.
|
|
170
|
+
*/
|
|
171
|
+
export const memoryReaderRegionStore = () => {
|
|
172
|
+
const regions = new Map();
|
|
173
|
+
return {
|
|
174
|
+
count: (counts, at, audience = DEFAULT_AUDIENCE_ID) => {
|
|
175
|
+
for (const count of counts) {
|
|
176
|
+
const key = inAudience(audience, regionKey(count));
|
|
177
|
+
const existing = regions.get(key);
|
|
178
|
+
regions.set(key, {
|
|
179
|
+
...count,
|
|
180
|
+
audienceId: audience,
|
|
181
|
+
views: (existing?.views ?? 0) + count.views,
|
|
182
|
+
updatedAt: at,
|
|
183
|
+
});
|
|
184
|
+
}
|
|
185
|
+
return Promise.resolve(ok(undefined));
|
|
186
|
+
},
|
|
187
|
+
regions: (request) => Promise.resolve(ok([...regions.values()].filter((row) => matches(row, request)))),
|
|
97
188
|
};
|
|
98
189
|
};
|
|
99
190
|
//# sourceMappingURL=memory.js.map
|