@aglyn/shared-ui-email-campaigns 1.0.0-beta.143

package/src/lib/model/email-record.d.ts

@@ -0,0 +1,175 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * READING ONE MESSAGE RECORD.
+ *
+ * A message — an email that was or will be sent — is a document under
+ * `hosts/{hostId}/campaigns`. Two facts about that document are awkward
+ * enough that every surface reading it gets them wrong the same way, so they
+ * are decided here once.
+ */
+/**
+ * When a message went out, or is due to.
+ *
+ * **There is no one SEND date field.** The send path writes `{status:'sent',
+ * sentAt}` from one branch and `{status:'scheduled', sendAtMs}` from another.
+ * So a list ordered on either field in Firestore does not mis-sort —
+ * `orderBy` DROPS every document missing the ordered field — and half the
+ * messages simply vanish. Sorting on this instead keeps both kinds in one
+ * ordered list.
+ *
+ * `sentAt` is a Firestore `Timestamp`, which the client SDK gives as an
+ * object with `seconds` and `toMillis()`; a document read from cache while a
+ * write is pending can carry a sentinel with neither, which reads as 0 and
+ * sorts last rather than throwing.
+ *
+ * A DRAFT correctly answers 0 here: it has no send time, and inventing one
+ * from its creation would put an unsent message on the timeline of mail that
+ * went out. Ordering a list is {@link emailListTimeMs}'s job.
+ *
+ * @returns epoch ms, or 0 when the message has no time at all.
+ */
+export declare function emailSendTimeMs(record: Record<string, any> | null | undefined): number;
+/**
+ * The field every writer of a message stamps when it MINTS the document.
+ *
+ * The one date on every message, which is what neither `sentAt` nor
+ * `sendAtMs` is — each is written by one branch of the send path and neither
+ * is on both kinds. A field carried by every record is the precondition for
+ * ordering this collection in Firestore rather than in the browser, because
+ * `orderBy` drops documents that lack the ordered field instead of
+ * mis-sorting them.
+ *
+ * Epoch milliseconds rather than a `Timestamp`, matching `sendAtMs` beside
+ * it: the two are compared against each other on every list that draws
+ * drafts and sends together, and a comparison that has to unwrap one side
+ * first is a comparison somebody writes wrong.
+ */
+export declare const EMAIL_CREATED_AT_FIELD = "createdAtMs";
+/**
+ * When a message was created, for the records that carry it.
+ *
+ * `null` — not 0 — for a record carrying no {@link EMAIL_CREATED_AT_FIELD},
+ * because 0 is a real instant at the far end of the sort and "we do not know"
+ * is not "1970". A null orders by the record's send time instead, so the list
+ * is correct for a record from any era.
+ */
+export declare function emailCreatedAtMs(record: Record<string, any> | null | undefined): number | null;
+/**
+ * WHERE A MESSAGE SITS IN A LIST OF MESSAGES.
+ *
+ * Its send time where it has one, and its creation time where it does not.
+ *
+ * A draft has neither `sentAt` nor `sendAtMs`, so ordering a list on the send
+ * time alone gives every draft the key 0 and files it below mail sent years
+ * ago — the newest thing a merchant did, at the bottom of the page, behind
+ * whatever paging the list has. Falling back to creation puts it where the
+ * merchant left it.
+ *
+ * The fallback is deliberately not the other way round. A SENT message orders
+ * by when it went out, never by when it was drafted: the list is a record of
+ * what happened, and a message drafted in March and sent in June belongs in
+ * June.
+ *
+ * @returns epoch ms, or 0 for a record with no time of any kind — a draft
+ *   written before the created stamp existed, which sorts last exactly as it
+ *   did before.
+ */
+export declare function emailListTimeMs(record: Record<string, any> | null | undefined): number;
+/**
+ * Reader-facing text for a message's state.
+ *
+ * The KEYS are persisted values written by the send path and read by the
+ * scheduled-campaign processor — nothing here may change them, including
+ * `canceled`, which is already the American spelling and is a stored enum in
+ * either case. Only the right-hand side is display text, and an unrecognized
+ * state falls through as itself rather than being flattened into one of
+ * these: a state this list cannot name is worth seeing.
+ *
+ * `draft` is an email that has been created and not sent. `sending` is the
+ * claim the scheduled processor and the send-now route both take before they
+ * mail, and it is named here because a merchant who reloads mid-send would
+ * otherwise be shown the raw token.
+ *
+ * ⚠️ **Not what a console row should draw.** This names the STORED value, and
+ * an email delivering an audience larger than one batch is stored as
+ * `scheduled` between runs — so a row rendering this says "Scheduled" about a
+ * send that has already put five hundred messages in five hundred inboxes.
+ * `campaignSendDisplay` in `campaign-container.ts` reads the counters beside
+ * the status and is what every surface here draws. This remains the honest
+ * answer to the narrower question of what one stored token means.
+ */
+export declare function emailStateLabel(status: unknown): string;
+/**
+ * Whether an email has yet been mailed to anybody.
+ *
+ * The surfaces that report on a send need this because an unsent email has no
+ * `stats` at all, and a report that divides into an absent denominator
+ * presents "not sent yet" as a delivery rate of 0% — the same class of fault
+ * as a rate rendered over a denominator it does not name.
+ */
+export declare function emailIsUnsent(record: Record<string, any> | null | undefined): boolean;
+/**
+ * Reader-facing names for the built-in audience kinds.
+ *
+ * The KEYS are the persisted `audience` values written on every message since
+ * the composer shipped; only the values on the right are display text. A
+ * `list` audience is deliberately absent — it is not a kind of audience, it
+ * is a NAMED one, and naming it is {@link emailAudienceLabel}'s job.
+ */
+export declare const EMAIL_AUDIENCE_LABELS: Record<string, string>;
+/**
+ * Which audience a message went to, named for a reader.
+ *
+ * A list send is named by the name the SEND recorded, never by the name the
+ * list carries today: resolving it now would let a rename rewrite the history
+ * of a message that went out months ago, and a deletion erase it. A send that
+ * recorded no name says so instead of printing a document id, which is not
+ * something a merchant recognises as a list.
+ */
+export declare function emailAudienceLabel(record: Record<string, any> | null | undefined): string;
+/**
+ * The sender a message actually left with, as this record has it.
+ *
+ * `recorded` is the whole point of the shape. The address a send goes out on
+ * is stamped by the send — see `sentAsStamp` — and every message sent before
+ * that stamp existed carries nothing, so a surface has to be able to tell an
+ * unrecorded sender apart from one it could compose. Composing it is the
+ * thing that must not happen: a site's sending identity is a setting, and
+ * resolving it now would answer "what would this send as today" on a report
+ * whose subject is a message that went out months ago, under whatever address
+ * the site held then.
+ *
+ * The same rule {@link emailAudienceLabel} follows for a list name, and for
+ * the same reason: the report says what happened, not what would happen now.
+ *
+ * `replyTo` is null on a message that set none, which is not missing
+ * information — a message with no `Reply-To:` takes replies at its `from`,
+ * and that is a fact the record states by omission rather than one it lost.
+ * The difference only reads correctly when `recorded` is true, which is why
+ * a caller must consult that first.
+ */
+export interface EmailSentAs {
+    /** False on a message sent before the send began stamping its sender. */
+    recorded: boolean;
+    from: string | null;
+    /** The display name recipients saw, or null when the address stood alone. */
+    fromName: string | null;
+    /** Where replies were pointed, or null when they go to `from`. */
+    replyTo: string | null;
+}
+export declare function emailSentAs(record: Record<string, any> | null | undefined): EmailSentAs;

package/src/lib/model/email-record.js

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * READING ONE MESSAGE RECORD.
+ *
+ * A message — an email that was or will be sent — is a document under
+ * `hosts/{hostId}/campaigns`. Two facts about that document are awkward
+ * enough that every surface reading it gets them wrong the same way, so they
+ * are decided here once.
+ */ /**
+ * When a message went out, or is due to.
+ *
+ * **There is no one SEND date field.** The send path writes `{status:'sent',
+ * sentAt}` from one branch and `{status:'scheduled', sendAtMs}` from another.
+ * So a list ordered on either field in Firestore does not mis-sort —
+ * `orderBy` DROPS every document missing the ordered field — and half the
+ * messages simply vanish. Sorting on this instead keeps both kinds in one
+ * ordered list.
+ *
+ * `sentAt` is a Firestore `Timestamp`, which the client SDK gives as an
+ * object with `seconds` and `toMillis()`; a document read from cache while a
+ * write is pending can carry a sentinel with neither, which reads as 0 and
+ * sorts last rather than throwing.
+ *
+ * A DRAFT correctly answers 0 here: it has no send time, and inventing one
+ * from its creation would put an unsent message on the timeline of mail that
+ * went out. Ordering a list is {@link emailListTimeMs}'s job.
+ *
+ * @returns epoch ms, or 0 when the message has no time at all.
+ */ export function emailSendTimeMs(record) {
+    var _ref;
+    const sentAt = record == null ? void 0 : record['sentAt'];
+    if (typeof (sentAt == null ? void 0 : sentAt.toMillis) === 'function') return sentAt.toMillis();
+    if (typeof (sentAt == null ? void 0 : sentAt.seconds) === 'number') return sentAt.seconds * 1000;
+    const scheduled = Number((_ref = record == null ? void 0 : record['sendAtMs']) != null ? _ref : 0);
+    return Number.isFinite(scheduled) ? scheduled : 0;
+}
+/**
+ * The field every writer of a message stamps when it MINTS the document.
+ *
+ * The one date on every message, which is what neither `sentAt` nor
+ * `sendAtMs` is — each is written by one branch of the send path and neither
+ * is on both kinds. A field carried by every record is the precondition for
+ * ordering this collection in Firestore rather than in the browser, because
+ * `orderBy` drops documents that lack the ordered field instead of
+ * mis-sorting them.
+ *
+ * Epoch milliseconds rather than a `Timestamp`, matching `sendAtMs` beside
+ * it: the two are compared against each other on every list that draws
+ * drafts and sends together, and a comparison that has to unwrap one side
+ * first is a comparison somebody writes wrong.
+ */ export const EMAIL_CREATED_AT_FIELD = 'createdAtMs';
+/**
+ * When a message was created, for the records that carry it.
+ *
+ * `null` — not 0 — for a record carrying no {@link EMAIL_CREATED_AT_FIELD},
+ * because 0 is a real instant at the far end of the sort and "we do not know"
+ * is not "1970". A null orders by the record's send time instead, so the list
+ * is correct for a record from any era.
+ */ export function emailCreatedAtMs(record) {
+    var _ref;
+    const created = Number((_ref = record == null ? void 0 : record[EMAIL_CREATED_AT_FIELD]) != null ? _ref : Number.NaN);
+    return Number.isFinite(created) && created > 0 ? created : null;
+}
+/**
+ * WHERE A MESSAGE SITS IN A LIST OF MESSAGES.
+ *
+ * Its send time where it has one, and its creation time where it does not.
+ *
+ * A draft has neither `sentAt` nor `sendAtMs`, so ordering a list on the send
+ * time alone gives every draft the key 0 and files it below mail sent years
+ * ago — the newest thing a merchant did, at the bottom of the page, behind
+ * whatever paging the list has. Falling back to creation puts it where the
+ * merchant left it.
+ *
+ * The fallback is deliberately not the other way round. A SENT message orders
+ * by when it went out, never by when it was drafted: the list is a record of
+ * what happened, and a message drafted in March and sent in June belongs in
+ * June.
+ *
+ * @returns epoch ms, or 0 for a record with no time of any kind — a draft
+ *   written before the created stamp existed, which sorts last exactly as it
+ *   did before.
+ */ export function emailListTimeMs(record) {
+    return emailSendTimeMs(record) || emailCreatedAtMs(record) || 0;
+}
+/**
+ * Reader-facing text for a message's state.
+ *
+ * The KEYS are persisted values written by the send path and read by the
+ * scheduled-campaign processor — nothing here may change them, including
+ * `canceled`, which is already the American spelling and is a stored enum in
+ * either case. Only the right-hand side is display text, and an unrecognized
+ * state falls through as itself rather than being flattened into one of
+ * these: a state this list cannot name is worth seeing.
+ *
+ * `draft` is an email that has been created and not sent. `sending` is the
+ * claim the scheduled processor and the send-now route both take before they
+ * mail, and it is named here because a merchant who reloads mid-send would
+ * otherwise be shown the raw token.
+ *
+ * ⚠️ **Not what a console row should draw.** This names the STORED value, and
+ * an email delivering an audience larger than one batch is stored as
+ * `scheduled` between runs — so a row rendering this says "Scheduled" about a
+ * send that has already put five hundred messages in five hundred inboxes.
+ * `campaignSendDisplay` in `campaign-container.ts` reads the counters beside
+ * the status and is what every surface here draws. This remains the honest
+ * answer to the narrower question of what one stored token means.
+ */ export function emailStateLabel(status) {
+    const value = String(status != null ? status : '');
+    if (value === 'sent') return 'Sent';
+    if (value === 'scheduled') return 'Scheduled';
+    if (value === 'canceled') return 'Canceled';
+    if (value === 'draft') return 'Draft';
+    if (value === 'sending') return 'Sending';
+    return value || 'Unknown';
+}
+/**
+ * Whether an email has yet been mailed to anybody.
+ *
+ * The surfaces that report on a send need this because an unsent email has no
+ * `stats` at all, and a report that divides into an absent denominator
+ * presents "not sent yet" as a delivery rate of 0% — the same class of fault
+ * as a rate rendered over a denominator it does not name.
+ */ export function emailIsUnsent(record) {
+    var _ref;
+    const value = String((_ref = record == null ? void 0 : record['status']) != null ? _ref : '');
+    return value === 'draft' || value === 'scheduled' || value === 'sending';
+}
+/**
+ * Reader-facing names for the built-in audience kinds.
+ *
+ * The KEYS are the persisted `audience` values written on every message since
+ * the composer shipped; only the values on the right are display text. A
+ * `list` audience is deliberately absent — it is not a kind of audience, it
+ * is a NAMED one, and naming it is {@link emailAudienceLabel}'s job.
+ */ export const EMAIL_AUDIENCE_LABELS = {
+    leads: 'All leads',
+    members: 'All site members',
+    segment: 'A contact segment',
+    manual: 'Addresses typed into the composer'
+};
+/**
+ * Which audience a message went to, named for a reader.
+ *
+ * A list send is named by the name the SEND recorded, never by the name the
+ * list carries today: resolving it now would let a rename rewrite the history
+ * of a message that went out months ago, and a deletion erase it. A send that
+ * recorded no name says so instead of printing a document id, which is not
+ * something a merchant recognises as a list.
+ */ export function emailAudienceLabel(record) {
+    var _ref, _ref1;
+    const audience = String((_ref = record == null ? void 0 : record['audience']) != null ? _ref : '');
+    if (audience !== 'list') {
+        var _ref2, _EMAIL_AUDIENCE_LABELS_audience;
+        return (_ref2 = (_EMAIL_AUDIENCE_LABELS_audience = EMAIL_AUDIENCE_LABELS[audience]) != null ? _EMAIL_AUDIENCE_LABELS_audience : audience) != null ? _ref2 : 'Not recorded';
+    }
+    const name = String((_ref1 = record == null ? void 0 : record['listName']) != null ? _ref1 : '');
+    if (name) return name;
+    return (record == null ? void 0 : record['listId']) ? 'A list this send did not name' : 'A list this send did not record';
+}
+export function emailSentAs(record) {
+    var _ref, _ref1, _ref2;
+    const stamp = record == null ? void 0 : record['sentAs'];
+    const from = String((_ref = stamp == null ? void 0 : stamp['from']) != null ? _ref : '').trim();
+    // The ADDRESS is what makes the stamp a record of a send. A `sentAs` map
+    // carrying only a display name is a partial write, and reporting it as
+    // recorded would put a name on screen beside an address nothing supplied.
+    if (!from) {
+        return {
+            recorded: false,
+            from: null,
+            fromName: null,
+            replyTo: null
+        };
+    }
+    return {
+        recorded: true,
+        from,
+        fromName: String((_ref1 = stamp == null ? void 0 : stamp['fromName']) != null ? _ref1 : '').trim() || null,
+        replyTo: String((_ref2 = stamp == null ? void 0 : stamp['replyTo']) != null ? _ref2 : '').trim() || null
+    };
+}
+
+//# sourceMappingURL=email-record.js.map

package/src/lib/model/email-record.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/shared/ui/email-campaigns/src/lib/model/email-record.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * READING ONE MESSAGE RECORD.\n *\n * A message — an email that was or will be sent — is a document under\n * `hosts/{hostId}/campaigns`. Two facts about that document are awkward\n * enough that every surface reading it gets them wrong the same way, so they\n * are decided here once.\n */\n\n/**\n * When a message went out, or is due to.\n *\n * **There is no one SEND date field.** The send path writes `{status:'sent',\n * sentAt}` from one branch and `{status:'scheduled', sendAtMs}` from another.\n * So a list ordered on either field in Firestore does not mis-sort —\n * `orderBy` DROPS every document missing the ordered field — and half the\n * messages simply vanish. Sorting on this instead keeps both kinds in one\n * ordered list.\n *\n * `sentAt` is a Firestore `Timestamp`, which the client SDK gives as an\n * object with `seconds` and `toMillis()`; a document read from cache while a\n * write is pending can carry a sentinel with neither, which reads as 0 and\n * sorts last rather than throwing.\n *\n * A DRAFT correctly answers 0 here: it has no send time, and inventing one\n * from its creation would put an unsent message on the timeline of mail that\n * went out. Ordering a list is {@link emailListTimeMs}'s job.\n *\n * @returns epoch ms, or 0 when the message has no time at all.\n */\nexport function emailSendTimeMs(\n  record: Record<string, any> | null | undefined,\n): number {\n  const sentAt = record?.['sentAt'] as\n    | { toMillis?: () => number; seconds?: number }\n    | undefined\n  if (typeof sentAt?.toMillis === 'function') return sentAt.toMillis()\n  if (typeof sentAt?.seconds === 'number') return sentAt.seconds * 1000\n  const scheduled = Number(record?.['sendAtMs'] ?? 0)\n  return Number.isFinite(scheduled) ? scheduled : 0\n}\n\n/**\n * The field every writer of a message stamps when it MINTS the document.\n *\n * The one date on every message, which is what neither `sentAt` nor\n * `sendAtMs` is — each is written by one branch of the send path and neither\n * is on both kinds. A field carried by every record is the precondition for\n * ordering this collection in Firestore rather than in the browser, because\n * `orderBy` drops documents that lack the ordered field instead of\n * mis-sorting them.\n *\n * Epoch milliseconds rather than a `Timestamp`, matching `sendAtMs` beside\n * it: the two are compared against each other on every list that draws\n * drafts and sends together, and a comparison that has to unwrap one side\n * first is a comparison somebody writes wrong.\n */\nexport const EMAIL_CREATED_AT_FIELD = 'createdAtMs'\n\n/**\n * When a message was created, for the records that carry it.\n *\n * `null` — not 0 — for a record carrying no {@link EMAIL_CREATED_AT_FIELD},\n * because 0 is a real instant at the far end of the sort and \"we do not know\"\n * is not \"1970\". A null orders by the record's send time instead, so the list\n * is correct for a record from any era.\n */\nexport function emailCreatedAtMs(\n  record: Record<string, any> | null | undefined,\n): number | null {\n  const created = Number(record?.[EMAIL_CREATED_AT_FIELD] ?? Number.NaN)\n  return Number.isFinite(created) && created > 0 ? created : null\n}\n\n/**\n * WHERE A MESSAGE SITS IN A LIST OF MESSAGES.\n *\n * Its send time where it has one, and its creation time where it does not.\n *\n * A draft has neither `sentAt` nor `sendAtMs`, so ordering a list on the send\n * time alone gives every draft the key 0 and files it below mail sent years\n * ago — the newest thing a merchant did, at the bottom of the page, behind\n * whatever paging the list has. Falling back to creation puts it where the\n * merchant left it.\n *\n * The fallback is deliberately not the other way round. A SENT message orders\n * by when it went out, never by when it was drafted: the list is a record of\n * what happened, and a message drafted in March and sent in June belongs in\n * June.\n *\n * @returns epoch ms, or 0 for a record with no time of any kind — a draft\n *   written before the created stamp existed, which sorts last exactly as it\n *   did before.\n */\nexport function emailListTimeMs(\n  record: Record<string, any> | null | undefined,\n): number {\n  return emailSendTimeMs(record) || emailCreatedAtMs(record) || 0\n}\n\n/**\n * Reader-facing text for a message's state.\n *\n * The KEYS are persisted values written by the send path and read by the\n * scheduled-campaign processor — nothing here may change them, including\n * `canceled`, which is already the American spelling and is a stored enum in\n * either case. Only the right-hand side is display text, and an unrecognized\n * state falls through as itself rather than being flattened into one of\n * these: a state this list cannot name is worth seeing.\n *\n * `draft` is an email that has been created and not sent. `sending` is the\n * claim the scheduled processor and the send-now route both take before they\n * mail, and it is named here because a merchant who reloads mid-send would\n * otherwise be shown the raw token.\n *\n * ⚠️ **Not what a console row should draw.** This names the STORED value, and\n * an email delivering an audience larger than one batch is stored as\n * `scheduled` between runs — so a row rendering this says \"Scheduled\" about a\n * send that has already put five hundred messages in five hundred inboxes.\n * `campaignSendDisplay` in `campaign-container.ts` reads the counters beside\n * the status and is what every surface here draws. This remains the honest\n * answer to the narrower question of what one stored token means.\n */\nexport function emailStateLabel(status: unknown): string {\n  const value = String(status ?? '')\n  if (value === 'sent') return 'Sent'\n  if (value === 'scheduled') return 'Scheduled'\n  if (value === 'canceled') return 'Canceled'\n  if (value === 'draft') return 'Draft'\n  if (value === 'sending') return 'Sending'\n  return value || 'Unknown'\n}\n\n/**\n * Whether an email has yet been mailed to anybody.\n *\n * The surfaces that report on a send need this because an unsent email has no\n * `stats` at all, and a report that divides into an absent denominator\n * presents \"not sent yet\" as a delivery rate of 0% — the same class of fault\n * as a rate rendered over a denominator it does not name.\n */\nexport function emailIsUnsent(\n  record: Record<string, any> | null | undefined,\n): boolean {\n  const value = String(record?.['status'] ?? '')\n  return value === 'draft' || value === 'scheduled' || value === 'sending'\n}\n\n/**\n * Reader-facing names for the built-in audience kinds.\n *\n * The KEYS are the persisted `audience` values written on every message since\n * the composer shipped; only the values on the right are display text. A\n * `list` audience is deliberately absent — it is not a kind of audience, it\n * is a NAMED one, and naming it is {@link emailAudienceLabel}'s job.\n */\nexport const EMAIL_AUDIENCE_LABELS: Record<string, string> = {\n  leads: 'All leads',\n  members: 'All site members',\n  segment: 'A contact segment',\n  manual: 'Addresses typed into the composer',\n}\n\n/**\n * Which audience a message went to, named for a reader.\n *\n * A list send is named by the name the SEND recorded, never by the name the\n * list carries today: resolving it now would let a rename rewrite the history\n * of a message that went out months ago, and a deletion erase it. A send that\n * recorded no name says so instead of printing a document id, which is not\n * something a merchant recognises as a list.\n */\nexport function emailAudienceLabel(\n  record: Record<string, any> | null | undefined,\n): string {\n  const audience = String(record?.['audience'] ?? '')\n  if (audience !== 'list') {\n    return EMAIL_AUDIENCE_LABELS[audience] ?? audience ?? 'Not recorded'\n  }\n  const name = String(record?.['listName'] ?? '')\n  if (name) return name\n  return record?.['listId']\n    ? 'A list this send did not name'\n    : 'A list this send did not record'\n}\n\n/**\n * The sender a message actually left with, as this record has it.\n *\n * `recorded` is the whole point of the shape. The address a send goes out on\n * is stamped by the send — see `sentAsStamp` — and every message sent before\n * that stamp existed carries nothing, so a surface has to be able to tell an\n * unrecorded sender apart from one it could compose. Composing it is the\n * thing that must not happen: a site's sending identity is a setting, and\n * resolving it now would answer \"what would this send as today\" on a report\n * whose subject is a message that went out months ago, under whatever address\n * the site held then.\n *\n * The same rule {@link emailAudienceLabel} follows for a list name, and for\n * the same reason: the report says what happened, not what would happen now.\n *\n * `replyTo` is null on a message that set none, which is not missing\n * information — a message with no `Reply-To:` takes replies at its `from`,\n * and that is a fact the record states by omission rather than one it lost.\n * The difference only reads correctly when `recorded` is true, which is why\n * a caller must consult that first.\n */\nexport interface EmailSentAs {\n  /** False on a message sent before the send began stamping its sender. */\n  recorded: boolean\n  from: string | null\n  /** The display name recipients saw, or null when the address stood alone. */\n  fromName: string | null\n  /** Where replies were pointed, or null when they go to `from`. */\n  replyTo: string | null\n}\n\nexport function emailSentAs(\n  record: Record<string, any> | null | undefined,\n): EmailSentAs {\n  const stamp = record?.['sentAs'] as Record<string, any> | null | undefined\n  const from = String(stamp?.['from'] ?? '').trim()\n  // The ADDRESS is what makes the stamp a record of a send. A `sentAs` map\n  // carrying only a display name is a partial write, and reporting it as\n  // recorded would put a name on screen beside an address nothing supplied.\n  if (!from) {\n    return { recorded: false, from: null, fromName: null, replyTo: null }\n  }\n  return {\n    recorded: true,\n    from,\n    fromName: String(stamp?.['fromName'] ?? '').trim() || null,\n    replyTo: String(stamp?.['replyTo'] ?? '').trim() || null,\n  }\n}\n"],"names":["emailSendTimeMs","record","sentAt","toMillis","seconds","scheduled","Number","isFinite","EMAIL_CREATED_AT_FIELD","emailCreatedAtMs","created","NaN","emailListTimeMs","emailStateLabel","status","value","String","emailIsUnsent","EMAIL_AUDIENCE_LABELS","leads","members","segment","manual","emailAudienceLabel","audience","name","emailSentAs","stamp","from","trim","recorded","fromName","replyTo"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;CAOC,GAED;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAASA,gBACdC,MAA8C;;IAE9C,MAAMC,SAASD,0BAAAA,MAAQ,CAAC,SAAS;IAGjC,IAAI,QAAOC,0BAAAA,OAAQC,QAAQ,MAAK,YAAY,OAAOD,OAAOC,QAAQ;IAClE,IAAI,QAAOD,0BAAAA,OAAQE,OAAO,MAAK,UAAU,OAAOF,OAAOE,OAAO,GAAG;IACjE,MAAMC,YAAYC,eAAOL,0BAAAA,MAAQ,CAAC,WAAW,mBAAI;IACjD,OAAOK,OAAOC,QAAQ,CAACF,aAAaA,YAAY;AAClD;AAEA;;;;;;;;;;;;;;CAcC,GACD,OAAO,MAAMG,yBAAyB,cAAa;AAEnD;;;;;;;CAOC,GACD,OAAO,SAASC,iBACdR,MAA8C;;IAE9C,MAAMS,UAAUJ,eAAOL,0BAAAA,MAAQ,CAACO,uBAAuB,mBAAIF,OAAOK,GAAG;IACrE,OAAOL,OAAOC,QAAQ,CAACG,YAAYA,UAAU,IAAIA,UAAU;AAC7D;AAEA;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,SAASE,gBACdX,MAA8C;IAE9C,OAAOD,gBAAgBC,WAAWQ,iBAAiBR,WAAW;AAChE;AAEA;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,OAAO,SAASY,gBAAgBC,MAAe;IAC7C,MAAMC,QAAQC,OAAOF,iBAAAA,SAAU;IAC/B,IAAIC,UAAU,QAAQ,OAAO;IAC7B,IAAIA,UAAU,aAAa,OAAO;IAClC,IAAIA,UAAU,YAAY,OAAO;IACjC,IAAIA,UAAU,SAAS,OAAO;IAC9B,IAAIA,UAAU,WAAW,OAAO;IAChC,OAAOA,SAAS;AAClB;AAEA;;;;;;;CAOC,GACD,OAAO,SAASE,cACdhB,MAA8C;;IAE9C,MAAMc,QAAQC,eAAOf,0BAAAA,MAAQ,CAAC,SAAS,mBAAI;IAC3C,OAAOc,UAAU,WAAWA,UAAU,eAAeA,UAAU;AACjE;AAEA;;;;;;;CAOC,GACD,OAAO,MAAMG,wBAAgD;IAC3DC,OAAO;IACPC,SAAS;IACTC,SAAS;IACTC,QAAQ;AACV,EAAC;AAED;;;;;;;;CAQC,GACD,OAAO,SAASC,mBACdtB,MAA8C;;IAE9C,MAAMuB,WAAWR,eAAOf,0BAAAA,MAAQ,CAAC,WAAW,mBAAI;IAChD,IAAIuB,aAAa,QAAQ;YAChBN,OAAAA;QAAP,QAAOA,SAAAA,kCAAAA,qBAAqB,CAACM,SAAS,YAA/BN,kCAAmCM,oBAAnCN,QAA+C;IACxD;IACA,MAAMO,OAAOT,gBAAOf,0BAAAA,MAAQ,CAAC,WAAW,oBAAI;IAC5C,IAAIwB,MAAM,OAAOA;IACjB,OAAOxB,CAAAA,0BAAAA,MAAQ,CAAC,SAAS,IACrB,kCACA;AACN;AAiCA,OAAO,SAASyB,YACdzB,MAA8C;;IAE9C,MAAM0B,QAAQ1B,0BAAAA,MAAQ,CAAC,SAAS;IAChC,MAAM2B,OAAOZ,eAAOW,yBAAAA,KAAO,CAAC,OAAO,mBAAI,IAAIE,IAAI;IAC/C,yEAAyE;IACzE,uEAAuE;IACvE,0EAA0E;IAC1E,IAAI,CAACD,MAAM;QACT,OAAO;YAAEE,UAAU;YAAOF,MAAM;YAAMG,UAAU;YAAMC,SAAS;QAAK;IACtE;IACA,OAAO;QACLF,UAAU;QACVF;QACAG,UAAUf,gBAAOW,yBAAAA,KAAO,CAAC,WAAW,oBAAI,IAAIE,IAAI,MAAM;QACtDG,SAAShB,gBAAOW,yBAAAA,KAAO,CAAC,UAAU,oBAAI,IAAIE,IAAI,MAAM;IACtD;AACF"}

package/src/lib/model/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The email-campaign document model: the stored shapes and the pure
+ * arithmetic over them.
+ *
+ * Nothing here imports React or MUI, so a server handler that needs a field
+ * name or a rate can take this barrel without dragging a component graph
+ * into its bundle. The renderers live one directory over, behind
+ * `@aglyn/shared-ui-email-campaigns/components/report-figures`.
+ */
+/**
+ * Campaign reporting: the rate math, the populations the send recorded, and
+ * the link rollup — pure, so every denominator is named once and provable
+ * rather than chosen in JSX.
+ */
+export * from './campaign-report';
+/**
+ * What a campaign EARNED: the last-click window, the gross/refunded pair and
+ * the per-currency buckets that are never added together. Separate from the
+ * rate math because it reads a different document and answers the merchant's
+ * second question rather than their first.
+ */
+export * from './campaign-revenue';
+/** Reading one message record — its state, and when it went out. */
+export * from './email-record';
+/**
+ * The campaign CONTAINER — its window, its lists, and the arithmetic that
+ * rolls its sends into one set of figures.
+ */
+export * from './campaign-container';
+export * from './campaign-send-time';
+/**
+ * What a campaign CAUSED: the four identify moments, kept apart because one
+ * visitor action writes several of them. Separate from the revenue module
+ * because it reads a different document and answers what happened to people
+ * who were anonymous until the moment being counted.
+ */
+export * from './campaign-conversions';

package/src/lib/model/index.js

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The email-campaign document model: the stored shapes and the pure
+ * arithmetic over them.
+ *
+ * Nothing here imports React or MUI, so a server handler that needs a field
+ * name or a rate can take this barrel without dragging a component graph
+ * into its bundle. The renderers live one directory over, behind
+ * `@aglyn/shared-ui-email-campaigns/components/report-figures`.
+ */ /**
+ * Campaign reporting: the rate math, the populations the send recorded, and
+ * the link rollup — pure, so every denominator is named once and provable
+ * rather than chosen in JSX.
+ */ export * from "./campaign-report.js";
+/**
+ * What a campaign EARNED: the last-click window, the gross/refunded pair and
+ * the per-currency buckets that are never added together. Separate from the
+ * rate math because it reads a different document and answers the merchant's
+ * second question rather than their first.
+ */ export * from "./campaign-revenue.js";
+/** Reading one message record — its state, and when it went out. */ export * from "./email-record.js";
+/**
+ * The campaign CONTAINER — its window, its lists, and the arithmetic that
+ * rolls its sends into one set of figures.
+ */ export * from "./campaign-container.js";
+export * from "./campaign-send-time.js";
+/**
+ * What a campaign CAUSED: the four identify moments, kept apart because one
+ * visitor action writes several of them. Separate from the revenue module
+ * because it reads a different document and answers what happened to people
+ * who were anonymous until the moment being counted.
+ */ export * from "./campaign-conversions.js";
+
+//# sourceMappingURL=index.js.map

package/src/lib/model/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/shared/ui/email-campaigns/src/lib/model/index.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The email-campaign document model: the stored shapes and the pure\n * arithmetic over them.\n *\n * Nothing here imports React or MUI, so a server handler that needs a field\n * name or a rate can take this barrel without dragging a component graph\n * into its bundle. The renderers live one directory over, behind\n * `@aglyn/shared-ui-email-campaigns/components/report-figures`.\n */\n\n/**\n * Campaign reporting: the rate math, the populations the send recorded, and\n * the link rollup — pure, so every denominator is named once and provable\n * rather than chosen in JSX.\n */\nexport * from './campaign-report'\n\n/**\n * What a campaign EARNED: the last-click window, the gross/refunded pair and\n * the per-currency buckets that are never added together. Separate from the\n * rate math because it reads a different document and answers the merchant's\n * second question rather than their first.\n */\nexport * from './campaign-revenue'\n\n/** Reading one message record — its state, and when it went out. */\nexport * from './email-record'\n\n/**\n * The campaign CONTAINER — its window, its lists, and the arithmetic that\n * rolls its sends into one set of figures.\n */\nexport * from './campaign-container'\n\nexport * from './campaign-send-time'\n\n/**\n * What a campaign CAUSED: the four identify moments, kept apart because one\n * visitor action writes several of them. Separate from the revenue module\n * because it reads a different document and answers what happened to people\n * who were anonymous until the moment being counted.\n */\nexport * from './campaign-conversions'\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;CAQC,GAED;;;;CAIC,GACD,cAAc,uBAAmB;AAEjC;;;;;CAKC,GACD,cAAc,wBAAoB;AAElC,kEAAkE,GAClE,cAAc,oBAAgB;AAE9B;;;CAGC,GACD,cAAc,0BAAsB;AAEpC,cAAc,0BAAsB;AAEpC;;;;;CAKC,GACD,cAAc,4BAAwB"}