@mohasinac/appkit 4.43.0 → 4.45.0

package/dist/_internal/shared/features/shipping/courier-rating.js

@@ -0,0 +1,114 @@
+/**
+ * Courier ratings — C5f. Two numbers, side by side, NEVER blended.
+ *
+ * ## 🛑 The one rule
+ *
+ * The carrier's own rating (Shiprocket's, when a booking exists) and ours are
+ * shown separately and are never averaged into a third figure.
+ *
+ * Same discipline as market-vs-sold price and estimated-vs-actual parcel
+ * weight, and for the same reason in all three cases: **the gap is the
+ * information**. A courier Shiprocket rates 4.8 and our own buyers rate 4.1 is
+ * telling us something specific — that the aggregate across their whole book of
+ * business does not describe our lanes, our parcels or our buyers. Averaging
+ * the two to 4.45 destroys exactly that signal and launders a vendor's number
+ * into one that looks like ours.
+ *
+ * ```
+ * Blue Dart Air      Shiprocket 4.8★ · LetItRip 4.5★ (23)   1–2 days   ₹140
+ * Delhivery Surface  Shiprocket 4.6★ · not enough data yet   3–5 days    ₹60
+ * ```
+ *
+ * ## 🛑 Below the threshold: "not enough data yet", never a number
+ *
+ * Identical rule to the price index, and it has to be, because a courier list
+ * is a choice made under time pressure: a 5.0 from one rating reads as better
+ * than a 4.6 from four hundred, and the reader has no way to know otherwise
+ * unless we decline to print it.
+ *
+ * ## What this module is NOT
+ *
+ * It does not query, it does not aggregate, and it does not fetch. The rollup
+ * runs as a pass in the existing daily job — a new Cloud Scheduler job would be
+ * a real registered cost (§ Firebase budget) for a number nobody reads hourly.
+ *
+ * 🛑 And `aggregateRatingJsonLd` stays `Product`-typed and is deliberately NOT
+ * extended to cover this. A courier rating is operational feedback for a
+ * fulfilment choice, not a product review; marking it up invites a rich result
+ * for something we do not sell.
+ */
+/**
+ * Below this, our own rating renders as a sample count and no star figure.
+ *
+ * Exported so the rollup, the projection and the view agree. A threshold one
+ * applied and another did not would either hide real data or publish an average
+ * of two votes as a reliability score.
+ */
+export const COURIER_RATING_MIN_CONFIDENT_SAMPLES = 5;
+/**
+ * What to render for one courier.
+ *
+ * 🛑 Returns a discriminated union rather than two optional numbers, because
+ * the four cases read differently and a renderer that has to decide will
+ * eventually print `0★` for one of them. The union makes "we have no rating"
+ * impossible to confuse with "we have a rating of zero".
+ */
+export function courierRatingDisplay(pair) {
+    const provider = typeof pair.providerRating === "number" && pair.providerRating > 0
+        ? pair.providerRating
+        : undefined;
+    const ours = pair.platformRating && pair.platformRating.count >= COURIER_RATING_MIN_CONFIDENT_SAMPLES
+        ? pair.platformRating
+        : undefined;
+    if (provider != null && ours) {
+        return { kind: "both", providerRating: provider, average: ours.average, count: ours.count };
+    }
+    if (provider != null) {
+        return { kind: "provider-only", providerRating: provider, ourLabel: "not enough data yet" };
+    }
+    if (ours)
+        return { kind: "ours-only", average: ours.average, count: ours.count };
+    return { kind: "none", label: "not rated yet" };
+}
+/**
+ * Is this vote acceptable?
+ *
+ * 🛑 One vote per user per ORDER, not per courier — a buyer who used Blue Dart
+ * four times has four legitimate opinions, and collapsing them to one would
+ * weight a frequent buyer the same as a one-off. Idempotency is by document id
+ * (`{orderId}__{userId}`), reusing the precedent `ReviewDocument.helpfulVoterIds`
+ * already sets rather than inventing a second one.
+ */
+export function isValidCourierVote(vote) {
+    if (!vote.courierId || !vote.orderId || !vote.userId)
+        return false;
+    if (typeof vote.rating !== "number" || !Number.isInteger(vote.rating))
+        return false;
+    return vote.rating >= 1 && vote.rating <= 5;
+}
+/** The deterministic id — a re-vote overwrites rather than double-counting. */
+export function courierVoteId(orderId, userId) {
+    return `${orderId}__${userId}`;
+}
+/**
+ * Roll a vote list into stats.
+ *
+ * Pure, so the daily job and any verification share one implementation.
+ * 🛑 Returns `null` for an empty list rather than a zeroed record — writing
+ * `average: 0, count: 0` would publish a courier as rated-zero, and a reader
+ * cannot tell that from a genuinely terrible courier.
+ */
+export function rollUpCourierVotes(courierId, votes, now) {
+    const valid = votes.filter((v) => isValidCourierVote(v));
+    if (valid.length === 0)
+        return null;
+    const sum = valid.reduce((s, v) => s + v.rating, 0);
+    const onTime = valid.filter((v) => v.onTime).length;
+    return {
+        courierId,
+        average: Math.round((sum / valid.length) * 100) / 100,
+        count: valid.length,
+        onTimeShare: Math.round((onTime / valid.length) * 100) / 100,
+        computedAt: now,
+    };
+}

package/dist/_internal/shared/features/shipping/mode.d.ts

@@ -0,0 +1,112 @@
+/**
+ * How a store prices shipping — C5b.
+ *
+ * ## What this replaces
+ *
+ * `resolveShippingCost(storeId)` returned ONE flat rupee number per store:
+ * `shippingConfig.customShippingPrice ?? 0`, read off the store OWNER's user
+ * document, with no weight, destination, pincode or courier anywhere in it.
+ *
+ * ## 🛑 And there was a second, richer config that no money path read
+ *
+ * `ShippingConfigDocument` (collection `shippingConfigs`) has `method`
+ * (free/flat/weight/express/pickup/custom), `flatRate`, `pricePerKg`,
+ * `freeAbove`, `expressSurcharge`, `estimatedDays` and `zones` — with full
+ * CRUD routes, a form schema and seed data. **`shippingConfigsRepository` is
+ * called from no money path at all.** So there were two shipping-config
+ * systems and the authoritative one was the flat number, by accident.
+ *
+ * This is the one mode, and it is deliberately narrower than that document:
+ *
+ *   `free`      the seller absorbs it. Implies they ship manually.
+ *   `flat`      a fixed amount the seller sets.
+ *   `estimate`  a live address-to-address carrier rate, which the buyer pays
+ *               and we HOLD — the escrow flow.
+ *
+ * Zones and per-kg tables are dropped: once a real carrier quotes the rate, a
+ * hand-maintained zone table earns nothing and is one more thing to drift.
+ *
+ * `freeAbove` SURVIVES as an override on every mode, because "free shipping
+ * over ₹999" is a merchandising lever no carrier can give you and every
+ * competitor in the crawl uses some form of it.
+ */
+/** Amounts are decimal rupees throughout, matching every other money field. */
+export type StoreShippingMode = {
+    kind: "free";
+} | {
+    kind: "flat";
+    amount: number;
+} | {
+    kind: "estimate";
+};
+export interface StoreShippingPolicy {
+    mode: StoreShippingMode;
+    /**
+     * Order goods value at or above which shipping is free, whatever the mode.
+     *
+     * 🛑 Compared against the GOODS value, not the grand total. Comparing a
+     * free-shipping threshold against a total that already includes shipping,
+     * GST and the platform fee makes the threshold depend on itself — a cart can
+     * cross ₹999 *because of* the shipping it is about to waive.
+     */
+    freeAbove?: number;
+}
+/**
+ * The default for a store that has configured nothing.
+ *
+ * 🛑 `free`, not `estimate`, and that is the conservative choice rather than
+ * the generous-looking one. `estimate` means we quote a live carrier rate and
+ * hold the buyer's money against a booking the seller may not be set up to
+ * make; a store that has never opened its shipping settings has not agreed to
+ * that. `free` charges the buyer nothing and leaves the seller shipping
+ * manually, which is what an unconfigured store was doing anyway — the old
+ * code's `?? 0` had exactly this effect, so this preserves behaviour for every
+ * existing store rather than silently switching them into escrow.
+ */
+export declare const DEFAULT_STORE_SHIPPING_POLICY: StoreShippingPolicy;
+/** Narrow an arbitrary stored value, falling back to the safe default. */
+export declare function toStoreShippingPolicy(raw: unknown): StoreShippingPolicy;
+export interface ShippingQuoteInput {
+    policy: StoreShippingPolicy;
+    /** GOODS value of this store's lines — see `freeAbove`. */
+    goodsValue: number;
+    /**
+     * The live carrier rate, when one was obtained.
+     *
+     * `null` means we could not get one — which is NOT the same as zero and is
+     * why this is nullable. See `quoteShipping`'s `needsCarrierRate`.
+     */
+    carrierRate?: number | null;
+}
+export type ShippingQuote = {
+    kind: "charge";
+    amount: number;
+    reason: "flat" | "estimate";
+} | {
+    kind: "free";
+    reason: "mode" | "freeAbove";
+}
+/**
+ * 🛑 The third outcome, and the reason this returns a union rather than a
+ * number. An `estimate`-mode store whose carrier rate could not be obtained
+ * has NO quote — and a `0` there would ship the parcel for free at our
+ * expense, silently, on every order until someone noticed. The caller must
+ * decide: block the purchase, or fall back. It cannot accidentally charge
+ * nothing.
+ */
+ | {
+    kind: "unavailable";
+    reason: "no-carrier-rate";
+};
+/**
+ * What this store's lines cost to ship.
+ *
+ * Order of resolution matters: `freeAbove` is checked FIRST, because a cart
+ * over the threshold is free regardless of mode and there is no point
+ * obtaining a carrier rate we are about to waive. That also means an
+ * `estimate`-mode store with a `freeAbove` does not fail on an unavailable
+ * carrier rate for a qualifying cart.
+ */
+export declare function quoteShipping(input: ShippingQuoteInput): ShippingQuote;
+/** Whether this quote needs a carrier call at all — saves a round trip. */
+export declare function needsCarrierRate(policy: StoreShippingPolicy, goodsValue: number): boolean;

package/dist/_internal/shared/features/shipping/mode.js

@@ -0,0 +1,108 @@
+/**
+ * How a store prices shipping — C5b.
+ *
+ * ## What this replaces
+ *
+ * `resolveShippingCost(storeId)` returned ONE flat rupee number per store:
+ * `shippingConfig.customShippingPrice ?? 0`, read off the store OWNER's user
+ * document, with no weight, destination, pincode or courier anywhere in it.
+ *
+ * ## 🛑 And there was a second, richer config that no money path read
+ *
+ * `ShippingConfigDocument` (collection `shippingConfigs`) has `method`
+ * (free/flat/weight/express/pickup/custom), `flatRate`, `pricePerKg`,
+ * `freeAbove`, `expressSurcharge`, `estimatedDays` and `zones` — with full
+ * CRUD routes, a form schema and seed data. **`shippingConfigsRepository` is
+ * called from no money path at all.** So there were two shipping-config
+ * systems and the authoritative one was the flat number, by accident.
+ *
+ * This is the one mode, and it is deliberately narrower than that document:
+ *
+ *   `free`      the seller absorbs it. Implies they ship manually.
+ *   `flat`      a fixed amount the seller sets.
+ *   `estimate`  a live address-to-address carrier rate, which the buyer pays
+ *               and we HOLD — the escrow flow.
+ *
+ * Zones and per-kg tables are dropped: once a real carrier quotes the rate, a
+ * hand-maintained zone table earns nothing and is one more thing to drift.
+ *
+ * `freeAbove` SURVIVES as an override on every mode, because "free shipping
+ * over ₹999" is a merchandising lever no carrier can give you and every
+ * competitor in the crawl uses some form of it.
+ */
+/**
+ * The default for a store that has configured nothing.
+ *
+ * 🛑 `free`, not `estimate`, and that is the conservative choice rather than
+ * the generous-looking one. `estimate` means we quote a live carrier rate and
+ * hold the buyer's money against a booking the seller may not be set up to
+ * make; a store that has never opened its shipping settings has not agreed to
+ * that. `free` charges the buyer nothing and leaves the seller shipping
+ * manually, which is what an unconfigured store was doing anyway — the old
+ * code's `?? 0` had exactly this effect, so this preserves behaviour for every
+ * existing store rather than silently switching them into escrow.
+ */
+export const DEFAULT_STORE_SHIPPING_POLICY = {
+    mode: { kind: "free" },
+};
+/** Narrow an arbitrary stored value, falling back to the safe default. */
+export function toStoreShippingPolicy(raw) {
+    if (!raw || typeof raw !== "object")
+        return DEFAULT_STORE_SHIPPING_POLICY;
+    const r = raw;
+    const freeAbove = typeof r.freeAbove === "number" && r.freeAbove > 0 ? { freeAbove: r.freeAbove } : {};
+    const kind = r.mode?.kind;
+    if (kind === "estimate")
+        return { mode: { kind: "estimate" }, ...freeAbove };
+    if (kind === "flat") {
+        const amount = Number(r.mode?.amount ?? 0);
+        /*
+         * A `flat` mode with no amount is not a flat rate, it is an unfinished
+         * form. Treating it as ₹0 would silently make it `free` and hide the
+         * misconfiguration; falling back to the default does the same thing
+         * VISIBLY, because the seller's settings page will show `free` selected
+         * and they can see it is not what they chose.
+         */
+        if (!(amount > 0))
+            return { ...DEFAULT_STORE_SHIPPING_POLICY, ...freeAbove };
+        return { mode: { kind: "flat", amount }, ...freeAbove };
+    }
+    return { ...DEFAULT_STORE_SHIPPING_POLICY, ...freeAbove };
+}
+/**
+ * What this store's lines cost to ship.
+ *
+ * Order of resolution matters: `freeAbove` is checked FIRST, because a cart
+ * over the threshold is free regardless of mode and there is no point
+ * obtaining a carrier rate we are about to waive. That also means an
+ * `estimate`-mode store with a `freeAbove` does not fail on an unavailable
+ * carrier rate for a qualifying cart.
+ */
+export function quoteShipping(input) {
+    const { policy, goodsValue, carrierRate } = input;
+    if (policy.freeAbove != null && goodsValue >= policy.freeAbove) {
+        return { kind: "free", reason: "freeAbove" };
+    }
+    switch (policy.mode.kind) {
+        case "free":
+            return { kind: "free", reason: "mode" };
+        case "flat":
+            return { kind: "charge", amount: policy.mode.amount, reason: "flat" };
+        case "estimate":
+            if (typeof carrierRate !== "number" || !(carrierRate >= 0)) {
+                return { kind: "unavailable", reason: "no-carrier-rate" };
+            }
+            return { kind: "charge", amount: carrierRate, reason: "estimate" };
+        default: {
+            // Exhaustive: a fourth mode must not compile to a silent free shipment.
+            const unreachable = policy.mode;
+            return unreachable;
+        }
+    }
+}
+/** Whether this quote needs a carrier call at all — saves a round trip. */
+export function needsCarrierRate(policy, goodsValue) {
+    if (policy.freeAbove != null && goodsValue >= policy.freeAbove)
+        return false;
+    return policy.mode.kind === "estimate";
+}

package/dist/_internal/shared/features/shipping/parcel.d.ts

@@ -0,0 +1,115 @@
+/**
+ * The parcel a shipment is quoted and booked on — C5a.
+ *
+ * ## 🛑 Three tiers, and the distinction between them is the whole point
+ *
+ *   CATEGORY   `CategoryProductDefaults.weightG` / `dimensionsCm` — a PACKED
+ *              figure, seeded per leaf. Drives the checkout ESTIMATE.
+ *   PRODUCT    `ProductDocument.weightG` / `dimensionsCm` — OPTIONAL. Refines
+ *              the estimate when a seller has actually weighed a packed box.
+ *   SHIPMENT   entered by the seller at booking time. **What is booked.**
+ *
+ * The figure a carrier bills on is the packed parcel, not the item: a bey is
+ * ~30 g and ~300 g boxed. A required product weight would therefore be an item
+ * weight that systematically under-estimates every booking — and since the
+ * booking is capped at the amount collected from the buyer, systematic
+ * under-estimation means silently absorbing the difference on every order.
+ *
+ * So the seller enters the real number when they have the box in front of
+ * them, and the category default exists only to quote with before that exists.
+ *
+ * ## 🛑 And the estimate must never silently become zero
+ *
+ * A missing weight cannot resolve to `0` — a carrier rate for a 0 g parcel is
+ * either an error or the cheapest band, and the cheapest band is the one that
+ * loses money. `resolveParcel` returns `null` when nothing is known, and every
+ * caller has to decide what to do about it rather than being handed a number
+ * that looks usable.
+ *
+ * Pure. No Firestore, no React.
+ */
+/** A dimension triple, all three or nothing — see `normaliseDimensions`. */
+export interface ParcelDimensionsCm {
+    l: number;
+    w: number;
+    h: number;
+}
+export interface Parcel {
+    weightG: number;
+    dimensionsCm?: ParcelDimensionsCm;
+    /**
+     * Which tier supplied the weight, so a surface can say so.
+     *
+     * Carried because "₹140 estimated" and "₹140 estimated from the category's
+     * typical packed weight, because this listing has none" are different claims,
+     * and the second is the honest one most of the time.
+     */
+    source: "shipment" | "product" | "category";
+}
+/** What a product or category can offer. Structural, so either shape fits. */
+export interface ParcelSource {
+    weightG?: number | null;
+    dimensionsCm?: {
+        l?: number | null;
+        w?: number | null;
+        h?: number | null;
+    } | null;
+}
+/**
+ * All three dimensions or none.
+ *
+ * A box with a length and no width is not a dimension — a carrier's volumetric
+ * calculation needs the triple, and feeding it two of three yields either an
+ * error or a quote for a flat sheet. The product form and the admin editor
+ * both enforce this at input; this is the read-side twin so a document written
+ * before they did cannot leak a partial triple into a rate request.
+ */
+export declare function normaliseDimensions(d: ParcelSource["dimensionsCm"]): ParcelDimensionsCm | undefined;
+/**
+ * Resolve the parcel to quote on, most specific tier first.
+ *
+ * 🛑 Returns `null` rather than a zero-weight parcel when no tier supplies a
+ * weight. A caller must then either refuse to quote or fall back to a
+ * non-carrier shipping mode — both of which are visible decisions, where a
+ * `0` would have been an invisible one.
+ *
+ * Dimensions are resolved INDEPENDENTLY of the weight, because the two are
+ * declared independently: a seller who typed a weight and no box size should
+ * still get the category's box size rather than none. Taking both from
+ * whichever tier won on weight would discard information that exists.
+ */
+export declare function resolveParcel(shipment: ParcelSource | null | undefined, product: ParcelSource | null | undefined, category: ParcelSource | null | undefined): Parcel | null;
+/**
+ * The weight of a whole order group — what a single shipment actually carries.
+ *
+ * Summed across lines and multiplied by live quantity, because a carrier
+ * quotes one parcel per shipment and two beys in one box weigh more than one.
+ *
+ * 🛑 Returns `null` if ANY line has no resolvable weight, rather than summing
+ * the ones it knows. A partial sum is a confident under-estimate, which is the
+ * exact failure this module exists to prevent — and it is worse than no
+ * estimate, because no estimate is visible.
+ */
+export declare function resolveGroupWeightG(lines: ReadonlyArray<{
+    quantity: number;
+    parcel: Parcel | null;
+}>): number | null;
+/**
+ * Actual against estimated, recorded and NEVER blended.
+ *
+ * Same discipline as the price index's market-vs-sold pair, for the same
+ * reason: the estimate is what we charged the buyer and the actual is what the
+ * carrier billed, and **the gap is the thing worth watching**. A leaf whose
+ * actuals run consistently over its default is telling us the default is
+ * wrong, which is a report for a human — not an automatic correction, because
+ * a default that chases its own actuals has no anchor.
+ */
+export interface ParcelWeightVariance {
+    estimatedG: number;
+    actualG: number;
+    /** Positive means the real parcel was HEAVIER than quoted. */
+    deltaG: number;
+    /** Signed fraction of the estimate, rounded to 3dp. `null` if estimate is 0. */
+    deltaRatio: number | null;
+}
+export declare function parcelWeightVariance(estimatedG: number, actualG: number): ParcelWeightVariance;

package/dist/_internal/shared/features/shipping/parcel.js

@@ -0,0 +1,120 @@
+/**
+ * The parcel a shipment is quoted and booked on — C5a.
+ *
+ * ## 🛑 Three tiers, and the distinction between them is the whole point
+ *
+ *   CATEGORY   `CategoryProductDefaults.weightG` / `dimensionsCm` — a PACKED
+ *              figure, seeded per leaf. Drives the checkout ESTIMATE.
+ *   PRODUCT    `ProductDocument.weightG` / `dimensionsCm` — OPTIONAL. Refines
+ *              the estimate when a seller has actually weighed a packed box.
+ *   SHIPMENT   entered by the seller at booking time. **What is booked.**
+ *
+ * The figure a carrier bills on is the packed parcel, not the item: a bey is
+ * ~30 g and ~300 g boxed. A required product weight would therefore be an item
+ * weight that systematically under-estimates every booking — and since the
+ * booking is capped at the amount collected from the buyer, systematic
+ * under-estimation means silently absorbing the difference on every order.
+ *
+ * So the seller enters the real number when they have the box in front of
+ * them, and the category default exists only to quote with before that exists.
+ *
+ * ## 🛑 And the estimate must never silently become zero
+ *
+ * A missing weight cannot resolve to `0` — a carrier rate for a 0 g parcel is
+ * either an error or the cheapest band, and the cheapest band is the one that
+ * loses money. `resolveParcel` returns `null` when nothing is known, and every
+ * caller has to decide what to do about it rather than being handed a number
+ * that looks usable.
+ *
+ * Pure. No Firestore, no React.
+ */
+/**
+ * All three dimensions or none.
+ *
+ * A box with a length and no width is not a dimension — a carrier's volumetric
+ * calculation needs the triple, and feeding it two of three yields either an
+ * error or a quote for a flat sheet. The product form and the admin editor
+ * both enforce this at input; this is the read-side twin so a document written
+ * before they did cannot leak a partial triple into a rate request.
+ */
+export function normaliseDimensions(d) {
+    if (!d)
+        return undefined;
+    const l = Number(d.l ?? 0);
+    const w = Number(d.w ?? 0);
+    const h = Number(d.h ?? 0);
+    if (!(l > 0 && w > 0 && h > 0))
+        return undefined;
+    return { l, w, h };
+}
+/**
+ * Resolve the parcel to quote on, most specific tier first.
+ *
+ * 🛑 Returns `null` rather than a zero-weight parcel when no tier supplies a
+ * weight. A caller must then either refuse to quote or fall back to a
+ * non-carrier shipping mode — both of which are visible decisions, where a
+ * `0` would have been an invisible one.
+ *
+ * Dimensions are resolved INDEPENDENTLY of the weight, because the two are
+ * declared independently: a seller who typed a weight and no box size should
+ * still get the category's box size rather than none. Taking both from
+ * whichever tier won on weight would discard information that exists.
+ */
+export function resolveParcel(shipment, product, category) {
+    const tiers = [
+        ["shipment", shipment],
+        ["product", product],
+        ["category", category],
+    ];
+    let weightG = null;
+    let source = null;
+    for (const [name, t] of tiers) {
+        const w = t?.weightG;
+        if (typeof w === "number" && w > 0) {
+            weightG = w;
+            source = name;
+            break;
+        }
+    }
+    if (weightG == null || source == null)
+        return null;
+    let dimensionsCm;
+    for (const [, t] of tiers) {
+        const d = normaliseDimensions(t?.dimensionsCm);
+        if (d) {
+            dimensionsCm = d;
+            break;
+        }
+    }
+    return { weightG, source, ...(dimensionsCm ? { dimensionsCm } : {}) };
+}
+/**
+ * The weight of a whole order group — what a single shipment actually carries.
+ *
+ * Summed across lines and multiplied by live quantity, because a carrier
+ * quotes one parcel per shipment and two beys in one box weigh more than one.
+ *
+ * 🛑 Returns `null` if ANY line has no resolvable weight, rather than summing
+ * the ones it knows. A partial sum is a confident under-estimate, which is the
+ * exact failure this module exists to prevent — and it is worse than no
+ * estimate, because no estimate is visible.
+ */
+export function resolveGroupWeightG(lines) {
+    let total = 0;
+    for (const line of lines) {
+        if (!line.parcel)
+            return null;
+        const qty = Math.max(1, line.quantity);
+        total += line.parcel.weightG * qty;
+    }
+    return total > 0 ? total : null;
+}
+export function parcelWeightVariance(estimatedG, actualG) {
+    const deltaG = Math.round((actualG - estimatedG) * 1000) / 1000;
+    return {
+        estimatedG,
+        actualG,
+        deltaG,
+        deltaRatio: estimatedG > 0 ? Math.round((deltaG / estimatedG) * 1000) / 1000 : null,
+    };
+}