shutro-erp 0.3.5 → 0.3.7

package/dist/purchase_stock/module.js

@@ -2,19 +2,31 @@
  * The data layer of the Purchase ↔ Stockroom bridge (RFC 0021): a confirmed purchase order gets its receipt — one
  * Stockroom transfer with a line per goods line, in the line's unit, from the vendors into the company's main
  * warehouse, expected on the order's arrival date — made once through the outbox (`purchase.order.confirmed`) and
- * confirmed. The order shows its receipts and what is received; each line, its received quantity.
+ * confirmed. The order shows its receipts and what is received; each line, its received quantity. An order may name
+ * the warehouse it is delivered to (the main one otherwise). Reorder rules that buy (RFC 0024 §2.6) order on
+ * requests for quotation to their vendor — a draft one from replenishment gets the new lines — and count what is
+ * on requests and orders not received yet as on order. Dropshipped products leave a delivery as it is confirmed:
+ * a dropship transfer from the vendor to the customer, with its request for quotation (no receipt: the vendor
+ * delivers).
  */
 import { productShutro } from '../product/index.js';
-import { purchaseShutro } from '../purchase/index.js';
+import { purchaseShutro, vendorPriceFor } from '../purchase/index.js';
 import { orm } from '../server/orm.js';
-import { defaultLocations, stockShutro } from '../stock/index.js';
+import { defaultLocations, inProductUnit, stockShutro } from '../stock/index.js';
 import { compute, defineModule, extendModel, f } from './.kosh/bindings.js';
+import { vendorScorecard } from './scorecard.js';
 const zero = orm.toDecimal(0);
 export const PickingPurchase = extendModel('stock.picking', {
     fields: {
         purchaseOrder: f.many2one('purchase.order', { ondelete: 'set null', label: 'Purchase order' }),
     },
     overrides: {
+        // Lines of products dropshipped from the warehouse leave the delivery for a dropship and its request.
+        routing: async function (next) {
+            await next();
+            const pickings = this;
+            await dropship(pickings.env, pickings.ids);
+        },
         // A backorder stays with its order.
         backorderValues: async function (next) {
             const out = await next();
@@ -40,17 +52,34 @@ export const MovePurchase = extendModel('stock.move', {
 });
 export const LineReceived = extendModel('purchase.order.line', {
     fields: {
+        /** What went back to the vendor by validated returns (RFC 0030 §3.2), in the line's unit. */
+        qtyReturned: f.decimal({
+            scale: 3,
+            store: true,
+            label: 'Returned',
+            help: 'What was sent back to the vendor by validated returns of its receipts.',
+            ...compute('purchase.order.line', 'qtyReturned', ['moves.quantity', 'moves.quantityDone', 'moves.picking.state', 'moves.returnOf'], (lines) => {
+                for (const l of lines)
+                    l.qtyReturned = [...l.moves]
+                        .filter((m) => m.picking.state === 'done' && m.returnOf !== null)
+                        .reduce((s, m) => s.plus(m.quantityDone ?? m.quantity), zero);
+            }),
+        }),
         moves: f.one2many('stock.move', 'purchaseLine'),
         /** Received by validated receipts, in the line's unit. */
         qtyReceived: f.decimal({
             scale: 3,
             store: true,
             label: 'Received',
-            ...compute('purchase.order.line', 'qtyReceived', ['moves.quantity', 'moves.quantityDone', 'moves.picking.state'], (lines) => {
+            ...compute('purchase.order.line', 'qtyReceived', ['moves.quantity', 'moves.quantityDone', 'moves.picking.state', 'moves.returnOf'], (lines) => {
+                // What went back to the vendor (a return of a receipt, RFC 0030 §3.2) is not received any more.
                 for (const l of lines)
                     l.qtyReceived = [...l.moves]
                         .filter((m) => m.picking.state === 'done')
-                        .reduce((s, m) => s.plus(m.quantityDone ?? m.quantity), zero);
+                        .reduce((s, m) => {
+                        const qty = m.quantityDone ?? m.quantity;
+                        return m.returnOf === null ? s.plus(qty) : s.minus(qty);
+                    }, zero);
             }),
         }),
     },
@@ -58,6 +87,32 @@ export const LineReceived = extendModel('purchase.order.line', {
 export const OrderReceipts = extendModel('purchase.order', {
     fields: {
         receipts: f.one2many('stock.picking', 'purchaseOrder'),
+        /** The vendor's on-time delivery rate (RFC 0030 §3.1), shown beside the expected arrival (RFC 0032 §3.4). */
+        vendorOnTime: f.char({
+            label: 'On-time delivery',
+            help: 'The share of the vendor’s receipts that arrived by their expected date.',
+            ...compute('purchase.order', 'vendorOnTime', ['partner'], async (orders) => {
+                const env = orders.env;
+                for (const o of orders) {
+                    // A new order has no vendor yet.
+                    if (o.partner === null) {
+                        o.vendorOnTime = '';
+                        continue;
+                    }
+                    const card = await vendorScorecard(env, o.partner.id);
+                    o.vendorOnTime =
+                        card.onTimeRate === null ? '' : `${card.onTimeRate}% on time (${card.onTime} receipts)`;
+                }
+            }),
+        }),
+        /** The vendor delivers to the customer: the order's transfer is a dropship, never received in stock. */
+        dropship: f.boolean({ default: false, label: 'Dropship' }),
+        /** Where the goods are received (the company's main warehouse when empty). */
+        warehouse: f.many2one('stock.warehouse', {
+            ondelete: 'set null',
+            checkCompany: true,
+            label: 'Deliver to',
+        }),
         receiptState: f.selection({
             nothing: 'Nothing to receive',
             to_receive: 'To receive',
@@ -91,7 +146,13 @@ export async function createReceiptFor(env, orderId) {
         const [order] = await su
             .model('purchase.order')
             .browse([orm.asId(orderId, 'purchase.order')])
-            .load({ lines: { product: true, uom: true }, partner: true, company: true, receipts: true });
+            .load({
+            lines: { product: true, uom: true },
+            partner: true,
+            company: true,
+            receipts: true,
+            warehouse: true,
+        });
         if (order === undefined || (order.state !== 'purchase' && order.state !== 'done'))
             return null;
         if ([...order.receipts].some((r) => r.state !== 'cancel'))
@@ -99,7 +160,7 @@ export async function createReceiptFor(env, orderId) {
         const goods = order.lines.filter((l) => l.product.kind === 'goods');
         if (goods.length === 0)
             return null;
-        const places = await defaultLocations(su, 'receipt', null, order.company.id);
+        const places = await defaultLocations(su, 'receipt', order.warehouse?.id ?? null, order.company.id);
         if (places.source === null || places.destination === null)
             throw new orm.ValidationError('purchase.order', ['state'], `The company of ${order.name} has no warehouse to receive into.`, 'Add a warehouse in Stockroom › Configuration › Warehouses.');
         const made = await su.model('stock.picking').create([
@@ -128,9 +189,256 @@ export async function createReceiptFor(env, orderId) {
         return made.ids[0] ?? null;
     });
 }
+const OPEN_RFQ = ['draft', 'sent', 'to_approve'];
+const isoPlus = (today, days) => {
+    const d = new Date(`${today}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() + days);
+    return d.toISOString().slice(0, 10);
+};
+/**
+ * Draft deliveries' lines of products with a dropship rule in the warehouse they leave from go to a dropship
+ * transfer per vendor — vendors to the delivery's customer, with every link of the delivery and its lines (a sales
+ * order's) — and a request for quotation to that vendor, marked as a dropship, linked line by line. A delivery left
+ * with no lines becomes the dropship itself.
+ */
+async function dropship(env, ids) {
+    await env.asSuperuser({ reason: 'dropship' }, async (su) => {
+        const [vendors] = (await su.model('stock.location').search({ where: { usage: 'vendor' }, limit: 1 })).ids;
+        if (vendors === undefined)
+            return;
+        const pickings = await su
+            .model('stock.picking')
+            .browse(ids)
+            .load({
+            source: { warehouse: true },
+            company: true,
+            moves: { product: { purchaseTaxes: true }, uom: true },
+        });
+        for (const p of pickings) {
+            const wh = p.source.warehouse;
+            if (p.kind !== 'delivery' || p.state !== 'draft' || wh === null)
+                continue;
+            const moves = [...p.moves];
+            const byVendor = new Map();
+            for (const m of moves) {
+                const [rule] = await (await su.model('stock.reorder').search({
+                    where: { product: m.product.id, warehouse: wh.id, method: 'dropship' },
+                    limit: 1,
+                })).load({ vendor: true });
+                if (rule?.vendor === null || rule?.vendor === undefined)
+                    continue;
+                const v = byVendor.get(rule.vendor.id) ?? { leadDays: rule.leadDays, moves: [] };
+                v.moves.push(m);
+                byVendor.set(rule.vendor.id, v);
+            }
+            if (byVendor.size === 0)
+                continue;
+            const total = byVendor.size === 1 && [...byVendor.values()][0]?.moves.length === moves.length;
+            const pickingValues = (await su.model('stock.picking').browse([p.id]).backorderValues()).get(p.id);
+            const today = su.today();
+            for (const [vendor, v] of byVendor) {
+                const made = await su.model('purchase.order').create([
+                    {
+                        partner: vendor,
+                        company: p.company.id,
+                        currency: p.company.currency.id,
+                        warehouse: wh.id,
+                        dropship: true,
+                        dateOrder: today,
+                        datePlanned: isoPlus(today, v.leadDays),
+                        origin: p.origin ?? p.name,
+                        lines: {
+                            create: v.moves.map((m) => ({
+                                product: m.product.id,
+                                name: m.name ?? m.product.name,
+                                quantity: m.quantity,
+                                uom: m.uom?.id ?? m.product.uom?.id ?? null,
+                                priceUnit: m.product.standardPrice,
+                                taxes: { set: [...m.product.purchaseTaxes.ids] },
+                            })),
+                        },
+                    },
+                ]);
+                const order = made.ids[0];
+                const orderLines = (await su.model('purchase.order.line').search({
+                    where: { order: order },
+                    order: ['id asc'],
+                })).ids;
+                if (total) {
+                    await su
+                        .model('stock.picking')
+                        .browse([p.id])
+                        .write({ kind: 'dropship', source: vendors, purchaseOrder: order });
+                    for (const [i, m] of v.moves.entries())
+                        await su
+                            .model('stock.move')
+                            .browse([m.id])
+                            .write({ purchaseLine: orderLines[i] ?? null });
+                    continue;
+                }
+                const lineValues = await su
+                    .model('stock.move')
+                    .browse(v.moves.map((m) => m.id))
+                    .backorderValues();
+                const split = await su.model('stock.picking').create([
+                    {
+                        ...pickingValues,
+                        kind: 'dropship',
+                        source: vendors,
+                        next: null,
+                        purchaseOrder: order,
+                        moves: {
+                            create: v.moves.map((m, i) => ({
+                                ...lineValues.get(m.id),
+                                quantity: m.quantity,
+                                purchaseLine: orderLines[i] ?? null,
+                            })),
+                        },
+                    },
+                ]);
+                await su
+                    .model('stock.move')
+                    .browse(v.moves.map((m) => m.id))
+                    .unlink();
+                await su
+                    .model('stock.picking')
+                    .browse(split.ids)
+                    .confirm();
+            }
+        }
+        await su.flush();
+    });
+}
+/** The warehouse an order is received into: its own, else the company's main one. */
+async function receivedInto(env, warehouse, company) {
+    return warehouse ?? (await defaultLocations(env, 'receipt', null, company)).warehouse;
+}
+/** The vendor price a buying rule would use for `qty`: in the company's currency, arriving within the rule's days. */
+async function chooseVendor(env, r, qty) {
+    const today = env.today();
+    const needBy = new Date(`${today}T00:00:00Z`);
+    needBy.setUTCDate(needBy.getUTCDate() + r.leadDays);
+    return vendorPriceFor(env, {
+        product: r.product.id,
+        quantity: orm.toDecimal(qty),
+        date: today,
+        currency: r.company.currency.id,
+        needBy: needBy.toISOString().slice(0, 10),
+    });
+}
+export const ReorderBuy = extendModel('stock.reorder', {
+    overrides: {
+        // Requests for quotation and orders not received yet (their receipt is still to be made) are on order.
+        pending: async function (next) {
+            const out = await next();
+            const rules = this;
+            const env = rules.env;
+            for (const r of await rules.load({ product: true })) {
+                const lines = await (await env.model('purchase.order.line').search({
+                    where: {
+                        product: r.product.id,
+                        'order.company': r.company.id,
+                        'order.state': { in: [...OPEN_RFQ, 'purchase', 'done'] },
+                    },
+                })).load({ order: { receipts: true }, uom: true, product: { uom: true } });
+                const found = out.get(r.id) ?? [];
+                for (const l of lines) {
+                    if (l.order.dropship)
+                        continue;
+                    if (!OPEN_RFQ.includes(l.order.state) && l.order.receipts.length > 0)
+                        continue;
+                    if ((await receivedInto(env, l.order.warehouse?.id ?? null, r.company.id)) !==
+                        r.warehouse.id)
+                        continue;
+                    const qty = inProductUnit(l.quantity, l.uom, l.product.uom);
+                    found.push({ quantity: qty.toString(), document: l.order.name });
+                }
+                out.set(r.id, found);
+            }
+            return out;
+        },
+        // The vendor a buying rule would order from, and why (RFC 0030 §3.1).
+        sourcing: async function (next, proposed) {
+            const out = await next(proposed);
+            const rules = this;
+            const env = rules.env;
+            for (const r of await rules.load({ company: true, vendor: true })) {
+                const qty = proposed.get(r.id);
+                if (r.method !== 'buy' || qty === undefined)
+                    continue;
+                const choice = await chooseVendor(env, r, qty);
+                out.set(r.id, choice === null
+                    ? r.vendor === null
+                        ? ''
+                        : `Bought from ${String(r.vendor.name)} (the rule’s vendor: no vendor price fits).`
+                    : `Bought from ${choice.vendorName}: ${choice.explanation}`);
+            }
+            return out;
+        },
+        // Buying: one request for quotation per vendor and warehouse — a draft one from replenishment gets the lines.
+        procure: async function (next, quantities) {
+            const out = await next(quantities);
+            const rules = this;
+            const env = rules.env;
+            const today = env.today();
+            for (const r of await rules.load({ product: { purchaseTaxes: true }, company: true })) {
+                const qty = quantities.get(r.id);
+                if (r.method !== 'buy' || qty === undefined)
+                    continue;
+                // The vendor prices choose the vendor (the cheapest that arrives in time); else the rule's vendor.
+                const choice = await chooseVendor(env, r, qty);
+                const vendor = choice?.vendor ?? r.vendor?.id ?? null;
+                if (vendor === null)
+                    continue;
+                const arrival = new Date(`${today}T00:00:00Z`);
+                arrival.setUTCDate(arrival.getUTCDate() + (choice?.leadDays ?? r.leadDays));
+                // The price comes from the vendor's price on the line (or the product's cost).
+                const line = {
+                    product: r.product.id,
+                    name: r.product.name,
+                    quantity: qty,
+                    uom: r.product.uom?.id ?? null,
+                    taxes: { set: [...r.product.purchaseTaxes.ids] },
+                };
+                const [open] = await (await env.model('purchase.order').search({
+                    where: {
+                        partner: vendor,
+                        company: r.company.id,
+                        warehouse: r.warehouse.id,
+                        state: 'draft',
+                        origin: 'Replenishment',
+                    },
+                    order: ['id desc'],
+                    limit: 1,
+                })).load({});
+                if (open !== undefined) {
+                    await env.model('purchase.order.line').create([{ ...line, order: open.id }]);
+                    out.set(r.id, open.name);
+                    continue;
+                }
+                const made = await env.model('purchase.order').create([
+                    {
+                        partner: vendor,
+                        company: r.company.id,
+                        currency: r.company.currency.id,
+                        warehouse: r.warehouse.id,
+                        dateOrder: today,
+                        datePlanned: arrival.toISOString().slice(0, 10),
+                        origin: 'Replenishment',
+                        lines: { create: [line] },
+                    },
+                ]);
+                const [order] = await made.load({});
+                out.set(r.id, order?.name ?? '');
+            }
+            await env.flush();
+            return out;
+        },
+    },
+});
 export const purchaseStockShutro = defineModule({
     name: 'purchase_stock',
-    version: '0.1.0',
+    version: '0.3.0',
     depends: [purchaseShutro, stockShutro, productShutro],
     groups: [
         orm.defineGroup({
@@ -140,5 +448,5 @@ export const purchaseStockShutro = defineModule({
         }),
     ],
     models: [],
-    extensions: [PickingPurchase, MovePurchase, LineReceived, OrderReceipts],
+    extensions: [PickingPurchase, MovePurchase, LineReceived, OrderReceipts, ReorderBuy],
 });

package/dist/purchase_stock/scorecard.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A vendor's scorecard (RFC 0030 §3.1), from what actually happened over the last year: the confirmed orders, the
+ * receipts done and how many by the order's expected date, the average days from order to receipt, and for the
+ * products bought most, the last price against the year's average. Read as the caller (Purchase users).
+ */
+import type { Env } from './.kosh/bindings.js';
+export interface Scorecard {
+    readonly orders: number;
+    readonly receipts: number;
+    readonly onTime: number;
+    /** Percent of receipts done by the expected date, or null without receipts. */
+    readonly onTimeRate: number | null;
+    readonly averageLeadDays: number | null;
+    readonly products: readonly {
+        readonly name: string;
+        readonly lastPrice: string;
+        readonly averagePrice: string;
+        /** Percent change of the last price against the average. */
+        readonly change: number;
+    }[];
+}
+export declare function vendorScorecard(env: Env, vendor: number): Promise<Scorecard>;

package/dist/purchase_stock/scorecard.js

@@ -0,0 +1,77 @@
+const ref = (env, name) => env.model(name);
+const dayOf = (v) => v instanceof Date ? v.toISOString().slice(0, 10) : String(v ?? '').slice(0, 10);
+const days = (from, to) => Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 86_400_000);
+const idOf = (v) => typeof v === 'number' ? v : (v?.id ?? null);
+const decimal = (v) => Number(String(v ?? '0'));
+export async function vendorScorecard(env, vendor) {
+    const today = env.today();
+    const since = new Date(`${today}T00:00:00Z`);
+    since.setUTCFullYear(since.getUTCFullYear() - 1);
+    const from = since.toISOString().slice(0, 10);
+    const orders = (await (await ref(env, 'purchase.order').search({
+        where: { partner: vendor, state: { in: ['purchase', 'done'] }, dateOrder: { gte: from } },
+    })).load(['dateOrder', 'datePlanned'])).read(['id', 'dateOrder', 'datePlanned']);
+    const byOrder = new Map(orders.map((o) => [o['id'], o]));
+    const receipts = orders.length === 0
+        ? []
+        : (await (await ref(env, 'stock.picking').search({
+            where: { purchaseOrder: { in: [...byOrder.keys()] }, state: 'done' },
+        })).load(['doneDate', 'purchaseOrder'])).read(['doneDate', 'purchaseOrder']);
+    let onTime = 0;
+    let lead = 0;
+    let counted = 0;
+    for (const r of receipts) {
+        const order = byOrder.get(idOf(r['purchaseOrder']) ?? -1);
+        if (order === undefined || r['doneDate'] == null)
+            continue;
+        const done = dayOf(r['doneDate']);
+        const expected = order['datePlanned'] == null ? null : dayOf(order['datePlanned']);
+        if (expected === null || done <= expected)
+            onTime++;
+        lead += days(dayOf(order['dateOrder']), done);
+        counted++;
+    }
+    const lines = orders.length === 0
+        ? []
+        : (await (await ref(env, 'purchase.order.line').search({
+            where: { order: { in: [...byOrder.keys()] } },
+            order: ['id asc'],
+        })).load({ product: true })).read(['product', 'priceUnit', 'quantity']);
+    const productIds = [...new Set(lines.map((l) => idOf(l['product'])).filter((p) => p !== null))];
+    const names = new Map(productIds.length === 0
+        ? []
+        : (await (await ref(env, 'product.product').search({ where: { id: { in: productIds } } })).load(['name']))
+            .read(['id', 'name'])
+            .map((p) => [p['id'], String(p['name'] ?? '')]));
+    const perProduct = new Map();
+    for (const l of lines) {
+        const id = idOf(l['product']);
+        if (id === null)
+            continue;
+        const entry = perProduct.get(id) ?? { name: names.get(id) ?? '', prices: [], quantity: 0 };
+        entry.prices.push(decimal(l['priceUnit']));
+        entry.quantity += decimal(l['quantity']);
+        perProduct.set(id, entry);
+    }
+    const products = [...perProduct.values()]
+        .sort((a, b) => b.quantity - a.quantity)
+        .slice(0, 5)
+        .map((e) => {
+        const last = e.prices.at(-1) ?? 0;
+        const average = e.prices.reduce((s, x) => s + x, 0) / e.prices.length;
+        return {
+            name: e.name,
+            lastPrice: last.toFixed(2),
+            averagePrice: average.toFixed(2),
+            change: average === 0 ? 0 : Math.round(((last - average) / average) * 1000) / 10,
+        };
+    });
+    return {
+        orders: orders.length,
+        receipts: counted,
+        onTime,
+        onTimeRate: counted === 0 ? null : Math.round((onTime / counted) * 1000) / 10,
+        averageLeadDays: counted === 0 ? null : Math.round((lead / counted) * 10) / 10,
+        products,
+    };
+}

package/dist/purchase_stock/web/Scorecard.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The vendor's scorecard on their contact (RFC 0030 §3.1): on-time receipts, average lead days and the price trend
+ * of what is bought most, over the last year. Shown to Purchase users for vendors with orders; the server computes.
+ */
+import type { NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function VendorScorecard({ record, api }: NodeComponentProps): ReactElement | null;

package/dist/purchase_stock/web/Scorecard.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useQuery } from '@tanstack/react-query';
+import { useId } from 'react';
+import { useTranslation } from 'react-i18next';
+export function VendorScorecard({ record, api }) {
+    const { t } = useTranslation('purchase_stock');
+    const id = useId();
+    const card = useQuery({
+        queryKey: ['purchase', 'scorecard', record?.id],
+        queryFn: () => api.call('GET', `/api/v1/purchase/vendors/${record?.id}/scorecard`),
+        enabled: record !== null && record['isVendor'] === true,
+        retry: false,
+    });
+    const c = card.data;
+    if (c === undefined || c.orders === 0)
+        return null;
+    return (_jsxs("section", { "aria-labelledby": `${id}-title`, className: "grid gap-2 rounded-md border p-3 text-sm", children: [_jsx("h3", { id: `${id}-title`, className: "font-medium", children: t('scorecard.title') }), _jsxs("dl", { className: "grid grid-cols-3 gap-2", children: [_jsxs("div", { children: [_jsx("dt", { className: "text-muted-foreground", children: t('scorecard.onTime') }), _jsx("dd", { className: "text-lg font-semibold tabular-nums", children: c.onTimeRate === null ? '—' : `${c.onTimeRate}%` }), _jsx("dd", { className: "text-xs text-muted-foreground", children: t('scorecard.receipts', { onTime: c.onTime, count: c.receipts }) })] }), _jsxs("div", { children: [_jsx("dt", { className: "text-muted-foreground", children: t('scorecard.lead') }), _jsx("dd", { className: "text-lg font-semibold tabular-nums", children: c.averageLeadDays === null ? '—' : t('scorecard.days', { count: c.averageLeadDays }) })] }), _jsxs("div", { children: [_jsx("dt", { className: "text-muted-foreground", children: t('scorecard.orders') }), _jsx("dd", { className: "text-lg font-semibold tabular-nums", children: c.orders })] })] }), c.products.length === 0 ? null : (_jsx("ul", { className: "grid gap-0.5", children: c.products.map((p) => (_jsxs("li", { className: "flex justify-between gap-2", children: [_jsx("span", { className: "truncate", children: p.name }), _jsx("span", { className: "tabular-nums", children: t('scorecard.price', {
+                                last: p.lastPrice,
+                                average: p.averagePrice,
+                                change: `${p.change > 0 ? '+' : ''}${p.change}`,
+                            }) })] }, p.name))) }))] }));
+}

package/dist/purchase_stock/web/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/purchase_stock`: the vendor scorecard on contacts (RFC 0030 §3.1).
+ */
+import { type Registry } from '../../ui/index.js';
+import type { i18n } from 'i18next';
+import { messages } from './messages.js';
+export { VendorScorecard } from './Scorecard.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export declare function registerPurchaseStockWeb(registry: Registry, i18n?: i18n): Registry;
+export { messages as purchaseStockMessages };

package/dist/purchase_stock/web/index.js

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/purchase_stock`: the vendor scorecard on contacts (RFC 0030 §3.1).
+ */
+import { addMessages } from '../../ui/index.js';
+import { messages } from './messages.js';
+import { VendorScorecard } from './Scorecard.js';
+export { VendorScorecard } from './Scorecard.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export function registerPurchaseStockWeb(registry, i18n) {
+    registry.registerComponent('purchase_stock.Scorecard', VendorScorecard);
+    if (i18n !== undefined)
+        addMessages(i18n, 'purchase_stock', messages);
+    return registry;
+}
+export { messages as purchaseStockMessages };

package/dist/purchase_stock/web/messages.d.ts

@@ -0,0 +1,2 @@
+/** Messages of the Purchase with receipts components (namespace `purchase_stock`), in English and Bangla. */
+export declare const messages: Readonly<Record<string, object>>;

package/dist/purchase_stock/web/messages.js

@@ -0,0 +1,27 @@
+/** Messages of the Purchase with receipts components (namespace `purchase_stock`), in English and Bangla. */
+export const messages = {
+    en: {
+        scorecard: {
+            title: 'Vendor scorecard (last 12 months)',
+            onTime: 'On time',
+            receipts: '{{onTime}} of {{count}} receipts',
+            lead: 'Average lead time',
+            days_one: '{{count}} day',
+            days_other: '{{count}} days',
+            orders: 'Orders',
+            price: 'last {{last}}, average {{average}} ({{change}}%)',
+        },
+    },
+    bn: {
+        scorecard: {
+            title: 'সরবরাহকারীর স্কোরকার্ড (গত ১২ মাস)',
+            onTime: 'সময়মতো',
+            receipts: '{{count}}টি রিসিটের {{onTime}}টি',
+            lead: 'গড় সরবরাহ সময়',
+            days_one: '{{count}} দিন',
+            days_other: '{{count}} দিন',
+            orders: 'অর্ডার',
+            price: 'শেষ {{last}}, গড় {{average}} ({{change}}%)',
+        },
+    },
+};

package/dist/purchase_stock_account/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: affe9e70bc2ae97c
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 70dff6019010b96d
 // Bindings of module `purchase_stock_account`: import the definition API from here to get types scoped to what it can see.
 export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
 import { definitions } from '../../server/orm.js';