@rightkit/social-ui 0.0.0-stage → 0.1.0

package/dist/data/money.d.ts

@@ -0,0 +1,14 @@
+/** Thousands grouping for a plain integer text, for example "18450" to "18,450". A leading "-" is kept. */
+export declare function groupDigits(text: string): string;
+/**
+ * Micro-units as currency text with six decimals, for example 2500000 to "2.500000" and -400000 to
+ * "-0.400000". Callers add the currency code. Exact for every safe integer.
+ */
+export declare function formatMicro(micro: number): string;
+/**
+ * Thousandths as exact decimal text, for example 1500 to "1.5", 250 to "0.25" and 4000 to "4". Works on the
+ * digits of the integer, so no float is used. Callers pass safe integers only.
+ */
+export declare function formatMilli(milli: number): string;
+/** The "YYYY-MM" month of a UTC instant, the form the allowance and report commands take. */
+export declare function monthOfInstant(utc: string): string;

package/dist/data/money.js

@@ -0,0 +1,36 @@
+// Exact money text. Amounts are integer micro-units (1,000,000 = 1 currency unit). Formatting works on
+// the decimal digits of the integer, so no float arithmetic is used. The data layer rejects any amount
+// that is not a safe integer before it reaches a screen (see mapping.ts, "Suggestions and spend").
+const MICRO_PER_UNIT_DIGITS = 6;
+/** Thousands grouping for a plain integer text, for example "18450" to "18,450". A leading "-" is kept. */
+export function groupDigits(text) {
+    const sign = text.startsWith("-") ? "-" : "";
+    const body = sign === "" ? text : text.slice(1);
+    return sign + body.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+/**
+ * Micro-units as currency text with six decimals, for example 2500000 to "2.500000" and -400000 to
+ * "-0.400000". Callers add the currency code. Exact for every safe integer.
+ */
+export function formatMicro(micro) {
+    const negative = micro < 0;
+    const digits = String(Math.abs(micro)).padStart(MICRO_PER_UNIT_DIGITS + 1, "0");
+    const whole = digits.slice(0, -MICRO_PER_UNIT_DIGITS);
+    const fraction = digits.slice(-MICRO_PER_UNIT_DIGITS);
+    return `${negative ? "-" : ""}${groupDigits(whole)}.${fraction}`;
+}
+/**
+ * Thousandths as exact decimal text, for example 1500 to "1.5", 250 to "0.25" and 4000 to "4". Works on the
+ * digits of the integer, so no float is used. Callers pass safe integers only.
+ */
+export function formatMilli(milli) {
+    const negative = milli < 0;
+    const digits = String(Math.abs(milli)).padStart(4, "0");
+    const whole = String(Number(digits.slice(0, -3)));
+    const fraction = digits.slice(-3).replace(/0+$/, "");
+    return `${negative ? "-" : ""}${groupDigits(whole)}${fraction === "" ? "" : `.${fraction}`}`;
+}
+/** The "YYYY-MM" month of a UTC instant, the form the allowance and report commands take. */
+export function monthOfInstant(utc) {
+    return utc.slice(0, 7);
+}

package/dist/data/platforms.d.ts

@@ -0,0 +1,12 @@
+import type { SocialPlatform } from "./types.js";
+/**
+ * Every account platform the engine knows, in the engine's order: PLATFORMS in
+ * crates/protocol/src/accounts.rs:22-33. Keep in step with the SocialPlatform union in types.ts.
+ */
+export declare const SOCIAL_PLATFORMS: readonly SocialPlatform[];
+/** True when the id is an account platform the desktop shows. A draft-only id such as "reddit" is not one. */
+export declare function isSocialPlatform(value: string): value is SocialPlatform;
+/** Draft-only platform ids the engine accepts beside the account vocabulary (drafts.rs, DRAFT_ONLY_PLATFORMS). */
+export declare const DRAFT_ONLY_PLATFORMS: readonly string[];
+/** True when the id is a platform the desktop shows: an account platform or a draft-only platform. */
+export declare function isKnownPlatform(value: string): boolean;

package/dist/data/platforms.js

@@ -0,0 +1,26 @@
+/**
+ * Every account platform the engine knows, in the engine's order: PLATFORMS in
+ * crates/protocol/src/accounts.rs:22-33. Keep in step with the SocialPlatform union in types.ts.
+ */
+export const SOCIAL_PLATFORMS = [
+    "instagram",
+    "facebook",
+    "threads",
+    "youtube",
+    "tiktok",
+    "x",
+    "linkedin",
+    "pinterest",
+    "bluesky",
+    "mastodon",
+];
+/** True when the id is an account platform the desktop shows. A draft-only id such as "reddit" is not one. */
+export function isSocialPlatform(value) {
+    return SOCIAL_PLATFORMS.includes(value);
+}
+/** Draft-only platform ids the engine accepts beside the account vocabulary (drafts.rs, DRAFT_ONLY_PLATFORMS). */
+export const DRAFT_ONLY_PLATFORMS = ["reddit"];
+/** True when the id is a platform the desktop shows: an account platform or a draft-only platform. */
+export function isKnownPlatform(value) {
+    return isSocialPlatform(value) || DRAFT_ONLY_PLATFORMS.includes(value);
+}

package/dist/data/source.d.ts

@@ -0,0 +1,196 @@
+import type { Account, AccountDisconnect, Campaign, CampaignAttribution, ChannelLink, DataError as BaseDataError, DataErrorCode as BaseDataErrorCode, DateRange, Digest, FailureItem, FailureResolution, HookTestSet, ModerationCapability, PublishJob, PublishJobRecord, ReconcileResult, ManualDraft, OperatorScope, OptimiseProposal, RejectDecision, SpendAllowance, SpendPrice, SpendReport, ThreadItem, TrackedLink, ContentDetail, ContentExperimentSummary, ContentRecord, DigestApplication, ResearchDigest, DeliveryEnvelope, DispatchAttempt, GateCheck, GatePolicy, GateRecord, OutgoingBrief, OutgoingBriefDetail, ChannelMemoryDetail, ChannelMemoryRevision, ProofRecord, ProofStatus, TypedBrief, BriefVariant, AnalyticsObservation, AnalyticsPost, MetricImport, HeartbeatStatus, RestoreReceiptList, InboxListing, InboxRaw, InboxStats, PublishNextView, PublishQuota } from "./types.js";
+/**
+ * Codes the engine returns that types.ts does not list. They are declared here, not in types.ts,
+ * so this change stays inside the engine data source. Move them into types.ts with the next change
+ * to that file.
+ *   foreign_scope       the scope matches no stored channel
+ *   engine_unavailable  the engine has no method or field for this yet; the message names it
+ *   engine_error        any other engine error; `engineCode` carries the engine's own code
+ */
+export type EngineOnlyErrorCode = "foreign_scope" | "engine_unavailable" | "engine_error";
+export type DataErrorCode = BaseDataErrorCode | EngineOnlyErrorCode;
+export interface DataError extends Omit<BaseDataError, "code"> {
+    code: DataErrorCode;
+    /** Set on engine_error: the engine's own error code. */
+    engineCode?: string;
+}
+/**
+ * A typed result. Every value in types.ts still fits: the mock's Result<T> is assignable to this.
+ */
+export type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: DataError;
+};
+/**
+ * An account the engine holds that the desktop cannot map yet: its platform is not in SOCIAL_PLATFORMS, or a
+ * state is not shown. It is listed apart from the mapped accounts, with its raw id and the reason. Never dropped.
+ */
+export interface UnmappedAccount {
+    /** The desktop account id the account would have had. */
+    id: string;
+    /** The engine's raw platform id, shown as stored. */
+    platform: string;
+    reason: string;
+}
+/**
+ * The seam between the screens and the daemon. The screens import only this interface. Today the
+ * only implementation is MockDataSource. The daemon client implements the same methods later, so
+ * no screen changes when it lands.
+ *
+ * Rule carried from the daemon: approve and reject fail on any mismatch between the revision or
+ * account the operator saw and the job the daemon holds. Nothing is applied on mismatch.
+ */
+export interface DataSource {
+    /** "mock" shows the Mock data banner on every screen. */
+    readonly kind: "mock" | "daemon";
+    /** The daemon's clock. Countdowns and "today" are computed from this, never from the browser. */
+    nowUtc(): string;
+    listAccounts(): Promise<Account[]>;
+    /** The accounts the last listAccounts could not map. Optional: the mock holds none. Read after listAccounts. */
+    unmappedAccounts?(): readonly UnmappedAccount[];
+    listJobs(range: DateRange): Promise<PublishJob[]>;
+    getJob(jobId: string): Promise<PublishJob | null>;
+    approve(jobId: string, revision: number, accountId: string): Promise<Result<PublishJob>>;
+    reject(jobId: string, decision: RejectDecision): Promise<Result<PublishJob>>;
+    pauseAccount(accountId: string, reason: string): Promise<Result<Account>>;
+    resumeAccount(accountId: string): Promise<Result<Account>>;
+    /**
+     * Ends the connection to the platform and cancels the account's queued and waiting posts. The engine stores no
+     * token, so the revocation is its state change; the person also revokes access in the platform's own settings.
+     * Does not delete data (a deletion request does).
+     */
+    disconnectAccount(accountId: string): Promise<Result<AccountDisconnect>>;
+    listFailures(): Promise<FailureItem[]>;
+    /** Asks the platform whether an outcome_unknown post exists. A read only; never publishes. */
+    reconcile(jobId: string): Promise<Result<ReconcileResult>>;
+    /**
+     * Records how a failure ended. The daemon enforces the rules: a published or cancelled outcome
+     * needs a matching reconcile result, acceptance as lost needs a note, and an alert takes only
+     * "acknowledged".
+     */
+    resolveFailure(failureId: string, resolution: FailureResolution, note: string): Promise<Result<FailureItem>>;
+    listDigest(): Promise<Digest>;
+    /** Every publish job of one channel, newest first. An empty list is a state, not an error. */
+    listPublishJobs(scopeId: string): Promise<PublishJobRecord[]>;
+    listThreads(): Promise<ThreadItem[]>;
+    resolveThread(threadId: string): Promise<Result<ThreadItem>>;
+    /** Snoozes a thread until a UTC instant that must be in the future. */
+    snoozeThread(threadId: string, untilUtc: string): Promise<Result<ThreadItem>>;
+    listModerationCapabilities(): Promise<ModerationCapability[]>;
+    listDrafts(): Promise<ManualDraft[]>;
+    /**
+     * Approves a drafted draft at exactly `revision`. The caller supplies the disclosure phrases; the
+     * engine has no built-in list. The engine's gate decides, and a refusal changes nothing.
+     */
+    approveDraft(draftId: string, revision: number, disclosurePhrases: readonly string[]): Promise<Result<ManualDraft>>;
+    /** Records the operator's post. The link must be https on an allowed host for the platform. */
+    markDraftPosted(draftId: string, revision: number, postedUrl: string): Promise<Result<ManualDraft>>;
+    /** Ends a drafted or approved draft with a reason. The reason is required. */
+    skipDraft(draftId: string, revision: number, reason: string): Promise<Result<ManualDraft>>;
+    listScopes(): Promise<OperatorScope[]>;
+    listProposals(scopeId: string): Promise<OptimiseProposal[]>;
+    /** Null when the suggestion is not in this scope. */
+    getProposal(scopeId: string, proposalId: string): Promise<OptimiseProposal | null>;
+    /**
+     * Accepts a suggestion at exactly `expectedRevision`. The engine creates one draft calendar entry and
+     * records its id. The entry still needs a real caption and approval; nothing is approved here.
+     */
+    acceptProposal(scopeId: string, proposalId: string, expectedRevision: number): Promise<Result<OptimiseProposal>>;
+    /** Dismisses a suggestion at exactly `expectedRevision`. Creates no calendar entry. */
+    dismissProposal(scopeId: string, proposalId: string, expectedRevision: number): Promise<Result<OptimiseProposal>>;
+    /** Null when no allowance is set for the month. That is a state, not an error. */
+    getAllowance(scopeId: string, month: string): Promise<SpendAllowance | null>;
+    /** Null when no allowance is set for the month. That is a state, not an error. */
+    spendReport(scopeId: string, month: string): Promise<SpendReport | null>;
+    listPrices(): Promise<SpendPrice[]>;
+    listCampaigns(scopeId: string): Promise<Campaign[]>;
+    /** Every tracked link of one campaign in the scope. An empty list is a state, not an error. */
+    listCampaignLinks(scopeId: string, campaignId: string): Promise<TrackedLink[]>;
+    /** Null when the campaign is not in this scope. */
+    campaignAttribution(scopeId: string, campaignId: string): Promise<CampaignAttribution | null>;
+    /**
+     * Every tracked link in one scope, across its campaigns, each with its campaign's name and visit count. The
+     * campaign order is the engine's, then variant, platform and link id. An empty list is a state, not an error.
+     */
+    listChannelLinks(scopeId: string): Promise<ChannelLink[]>;
+    listHookTests(scopeId: string): Promise<HookTestSet[]>;
+    /** Null when no set with this id is in the scope. */
+    getHookTest(scopeId: string, setId: string): Promise<HookTestSet | null>;
+    /** Every digest in one scope, ordered by digest date then id. */
+    listDigests(scopeId: string): Promise<ResearchDigest[]>;
+    /** Null when no digest with this id is in the scope. */
+    getDigest(scopeId: string, digestId: string): Promise<ResearchDigest | null>;
+    /** Which digest entries became draft calendar entries. Null when the digest is not in the scope. */
+    digestApplications(scopeId: string, digestId: string): Promise<DigestApplication[] | null>;
+    /** Every content record in one scope, ordered by content id. */
+    listContent(scopeId: string): Promise<ContentRecord[]>;
+    /** A record with its variants. Null when no record with this id is in the scope. */
+    getContent(scopeId: string, contentId: string): Promise<ContentDetail | null>;
+    /** The engine's variant comparison for one record. Null when the record is not in the scope. */
+    contentExperimentSummary(scopeId: string, contentId: string): Promise<ContentExperimentSummary | null>;
+    /** The latest memory revision with its document. Null when none has been written: a state, not an error. */
+    channelMemory(scopeId: string): Promise<ChannelMemoryDetail | null>;
+    /** Every stored memory revision, newest first, without documents. An empty list when none is stored. */
+    channelMemoryHistory(scopeId: string): Promise<ChannelMemoryRevision[]>;
+    /** The proofs of one scope, sorted by answer id. A null status lists every status. */
+    listProofs(scopeId: string, status: ProofStatus | null): Promise<ProofRecord[]>;
+    /** The latest gate policy of the scope. Null when none is set, which means nothing can pass. That is a state, not an error. */
+    gatePolicy(scopeId: string): Promise<GatePolicy | null>;
+    /**
+     * A dry-run check of one script with no claim annotations. Stores nothing. A refusal (for example hidden
+     * characters, or no policy) is a Result, not a throw.
+     */
+    checkText(scopeId: string, subjectId: string, text: string): Promise<Result<GateCheck>>;
+    /** The stored verdict records of one subject, newest first. A subject with none is an empty list. */
+    gateRecords(scopeId: string, subjectId: string): Promise<GateRecord[]>;
+    /** Every outgoing brief in one scope, ordered by request id. */
+    listBriefs(scopeId: string): Promise<OutgoingBrief[]>;
+    /** Null when no brief with this request id is in the scope. */
+    getBrief(scopeId: string, requestId: string): Promise<OutgoingBriefDetail | null>;
+    /** Every accepted delivery in one scope. */
+    listDeliveries(scopeId: string): Promise<DeliveryEnvelope[]>;
+    /** Null when no envelope with this id is in the scope. */
+    getDelivery(scopeId: string, envelopeId: string): Promise<DeliveryEnvelope | null>;
+    /** The dispatch attempts of one brief, oldest first. An empty list is a state, not an error. */
+    listDispatchAttempts(scopeId: string, requestId: string): Promise<DispatchAttempt[]>;
+    /** Every typed brief in one scope, ordered by brief id. */
+    listTypedBriefs(scopeId: string): Promise<TypedBrief[]>;
+    /** Null when no brief with this id is in the scope. */
+    getTypedBrief(scopeId: string, briefId: string): Promise<TypedBrief | null>;
+    /** The variants of one brief, ordered by platform then variant id. An empty list is a state, not an error. */
+    listBriefVariants(scopeId: string, briefId: string): Promise<BriefVariant[]>;
+    /** Every published post in one scope with its latest stored metrics. An empty list is a state, not an error. */
+    listAnalyticsPosts(scopeId: string): Promise<AnalyticsPost[]>;
+    /** Every stored observation of one post in the scope, oldest first. An empty list is a state, not an error. */
+    listAnalyticsObservations(scopeId: string, jobId: string): Promise<AnalyticsObservation[]>;
+    /** Every committed manual import in one scope. An empty list is a state, not an error. */
+    listMetricImports(scopeId: string): Promise<MetricImport[]>;
+    /**
+     * The daemon heartbeat record's state at `nowUtc`, against `staleAfterSecs`. The ages and states come from the engine
+     * as given. An empty list is a state, and it is not a sign of health.
+     */
+    heartbeatStatus(nowUtc: string, staleAfterSecs: number): Promise<HeartbeatStatus>;
+    /** Every restore receipt, newest first, with the receipt files that could not be read. */
+    listRestoreReceipts(): Promise<RestoreReceiptList>;
+    /** The newest page of events of one channel account, or of the unmatched events when scopeId is null. */
+    listInbox(scopeId: string | null): Promise<InboxListing>;
+    /** The raw item JSON of one event. Null when no event with this id is in the scope. */
+    getInboxEvent(scopeId: string | null, eventId: string): Promise<InboxRaw | null>;
+    /** Event and delivery counts as the daemon stores them. Whole store, not per channel. */
+    inboxStats(): Promise<InboxStats>;
+    /** What may run now on every account of one channel, and what may not, with reasons. Scope ids come from listScopes. */
+    listPublishNext(scopeId: string): Promise<PublishNextView>;
+    /**
+     * One account's pacing: the limits in force, the pause, the last create and the platform wait. Throws on a failed
+     * read, so the screen shows the error for that account only.
+     */
+    getPublishQuota(scopeId: string, platform: string, remoteAccount: string): Promise<PublishQuota>;
+    /** Present only on the mock. Lets the preview simulate an edit made on another device. */
+    readonly mock?: MockControls;
+}
+export interface MockControls {
+    simulateCaptionChange(jobId: string, caption: string): Promise<Result<PublishJob>>;
+}

package/dist/data/source.js

@@ -0,0 +1 @@
+export {};

package/dist/data/time.d.ts

@@ -0,0 +1,23 @@
+/** Calendar date ("YYYY-MM-DD") of an instant as seen in a zone. */
+export declare function dateKeyInZone(utc: string, timeZone: string): string;
+/** Wall-clock time "HH:MM" of an instant in a zone. */
+export declare function timeInZone(utc: string, timeZone: string): string;
+/** Zone abbreviation for display, for example "GMT+1" or "EDT". */
+export declare function zoneAbbr(utc: string, timeZone: string): string;
+/** Numeric UTC offset of an instant in a zone, for example "+01:00". */
+export declare function zoneOffset(utc: string, timeZone: string): string;
+/** "Tue 13 Oct" for a date key. */
+export declare function dayLabel(dateKey: string): string;
+/** Full instant label, for example "Tue 13 Oct 09:00 GMT+1 (Europe/Lisbon, +01:00)". */
+export declare function instantLabel(utc: string, timeZone: string): string;
+export declare function dateKeyAdd(dateKey: string, days: number): string;
+/** 0 for Monday through 6 for Sunday. */
+export declare function weekdayIndex(dateKey: string): number;
+export declare function mondayOf(dateKey: string): string;
+export declare function weekDays(mondayKey: string): string[];
+export declare function startOfDateUtc(dateKey: string): string;
+/** Remaining time from now until a target, for example "11 h 50 min". Returns "now" when past. */
+export declare function remaining(targetUtc: string, nowUtc: string): string;
+/** Whole days from now until a calendar date (UTC midnight), rounded up. Negative when past. */
+export declare function daysUntil(dateKey: string, nowUtc: string): number;
+export declare function formatCount(n: number): string;

package/dist/data/time.js

@@ -0,0 +1,86 @@
+// Time helpers. Instants are UTC ISO strings. Local wall-clock values come from Intl with the
+// account's IANA zone. Date keys are "YYYY-MM-DD" in the zone they were computed for.
+const DAY_MS = 86_400_000;
+const formatterCache = new Map();
+function formatter(key, make) {
+    let f = formatterCache.get(key);
+    if (!f) {
+        f = make();
+        formatterCache.set(key, f);
+    }
+    return f;
+}
+/** Calendar date ("YYYY-MM-DD") of an instant as seen in a zone. */
+export function dateKeyInZone(utc, timeZone) {
+    const f = formatter(`date|${timeZone}`, () => new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }));
+    const parts = f.formatToParts(new Date(utc));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? "00";
+    return `${get("year")}-${get("month")}-${get("day")}`;
+}
+/** Wall-clock time "HH:MM" of an instant in a zone. */
+export function timeInZone(utc, timeZone) {
+    const f = formatter(`time|${timeZone}`, () => new Intl.DateTimeFormat("en-GB", { timeZone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" }));
+    return f.format(new Date(utc));
+}
+/** Zone abbreviation for display, for example "GMT+1" or "EDT". */
+export function zoneAbbr(utc, timeZone) {
+    const f = formatter(`abbr|${timeZone}`, () => new Intl.DateTimeFormat("en-US", { timeZone, timeZoneName: "short" }));
+    return f.formatToParts(new Date(utc)).find((p) => p.type === "timeZoneName")?.value ?? timeZone;
+}
+/** Numeric UTC offset of an instant in a zone, for example "+01:00". */
+export function zoneOffset(utc, timeZone) {
+    const f = formatter(`offset|${timeZone}`, () => new Intl.DateTimeFormat("en-GB", { timeZone, timeZoneName: "longOffset" }));
+    const raw = f.formatToParts(new Date(utc)).find((p) => p.type === "timeZoneName")?.value ?? "GMT";
+    const offset = raw.replace("GMT", "");
+    return offset === "" ? "+00:00" : offset;
+}
+/** "Tue 13 Oct" for a date key. */
+export function dayLabel(dateKey) {
+    const f = formatter("dayLabel", () => new Intl.DateTimeFormat("en-GB", { timeZone: "UTC", weekday: "short", day: "numeric", month: "short" }));
+    return f.format(new Date(`${dateKey}T12:00:00Z`));
+}
+/** Full instant label, for example "Tue 13 Oct 09:00 GMT+1 (Europe/Lisbon, +01:00)". */
+export function instantLabel(utc, timeZone) {
+    const key = dateKeyInZone(utc, timeZone);
+    return `${dayLabel(key)} ${timeInZone(utc, timeZone)} ${zoneAbbr(utc, timeZone)} (${timeZone}, ${zoneOffset(utc, timeZone)})`;
+}
+export function dateKeyAdd(dateKey, days) {
+    const ms = Date.parse(`${dateKey}T00:00:00Z`) + days * DAY_MS;
+    return new Date(ms).toISOString().slice(0, 10);
+}
+/** 0 for Monday through 6 for Sunday. */
+export function weekdayIndex(dateKey) {
+    const day = new Date(`${dateKey}T00:00:00Z`).getUTCDay();
+    return (day + 6) % 7;
+}
+export function mondayOf(dateKey) {
+    return dateKeyAdd(dateKey, -weekdayIndex(dateKey));
+}
+export function weekDays(mondayKey) {
+    return Array.from({ length: 7 }, (_, i) => dateKeyAdd(mondayKey, i));
+}
+export function startOfDateUtc(dateKey) {
+    return `${dateKey}T00:00:00Z`;
+}
+/** Remaining time from now until a target, for example "11 h 50 min". Returns "now" when past. */
+export function remaining(targetUtc, nowUtc) {
+    const ms = Date.parse(targetUtc) - Date.parse(nowUtc);
+    if (ms <= 0)
+        return "now";
+    const totalMin = Math.ceil(ms / 60_000);
+    const hours = Math.floor(totalMin / 60);
+    const mins = totalMin % 60;
+    if (hours === 0)
+        return `${mins} min`;
+    if (hours < 48)
+        return `${hours} h ${mins} min`;
+    return `${Math.floor(hours / 24)} days`;
+}
+/** Whole days from now until a calendar date (UTC midnight), rounded up. Negative when past. */
+export function daysUntil(dateKey, nowUtc) {
+    const ms = Date.parse(`${dateKey}T00:00:00Z`) - Date.parse(nowUtc);
+    return Math.ceil(ms / DAY_MS);
+}
+export function formatCount(n) {
+    return n.toLocaleString("en-GB");
+}