@aglyn/plugins-crm 1.0.0-beta.143

package/src/lib/model/deal-board-model.d.ts

@@ -0,0 +1,241 @@
+/**
+ * @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 pipeline's arithmetic and the stage editor's rules (AGL-2598), as pure
+ * functions — no Firestore, no React — so the board, the table, the detail
+ * page and the server route read one definition of "what is this pipeline
+ * worth" and "which stage edits are legal".
+ */
+import { type CrmDeal, type CrmDealStage, type CrmPipeline } from '@aglyn/aglyn/app-utils/crm';
+/** A deal as the console reads it: the model plus its document id. */
+export type DealDoc = CrmDeal & {
+    $id: string;
+    /**
+     * The contact's and the company's names, copied onto the deal when the
+     * link is made. A board of two hundred cards cannot afford a keyed read per
+     * card to caption each one, and the caption is allowed to lag a rename —
+     * the link itself is the id, which never changes.
+     */
+    contactName?: string;
+    companyName?: string;
+};
+/** A pipeline as the console reads it. */
+export type PipelineDoc = CrmPipeline & {
+    $id: string;
+};
+/** The document id the seeded default pipeline is written under. */
+export declare const DEFAULT_PIPELINE_ID = "default";
+/** Name of the pipeline every org starts with. */
+export declare const DEFAULT_PIPELINE_NAME = "Sales";
+export declare const PIPELINE_NAME_MAX = 60;
+/** The pipelines a picker offers and a new deal may land in: the ones not archived. */
+export declare function activePipelines<T extends Pick<CrmPipeline, 'archivedAt'>>(pipelines: readonly T[]): T[];
+/**
+ * The pipeline a new deal lands in when nobody picks one: the active one
+ * marked default, else the first active one, else nothing. An archived
+ * pipeline is never the default even if its flag was left on — archiving
+ * clears the flag, but a document written by an older console may not
+ * have had it cleared, and a default nobody can create a deal in is a
+ * board that opens on a pipeline the picker does not list.
+ */
+export declare function defaultPipelineOf<T extends Pick<CrmPipeline, 'archivedAt' | 'isDefault'>>(pipelines: readonly T[]): T | null;
+/**
+ * Why a pipeline cannot be created or renamed to `name`, or `null`.
+ *
+ * Names are unique among the ACTIVE pipelines, compared without case: the
+ * picker lists them by name alone, and two rows reading "Sales" would be a
+ * choice nobody can make. An archived pipeline's name is free to reuse —
+ * "Sales 2025" retired and "Sales" started over is the point of archiving.
+ */
+export declare function pipelineNameProblem(name: string, pipelines: ReadonlyArray<Pick<CrmPipeline, 'name' | 'archivedAt'> & {
+    $id: string;
+}>, ownId?: string): string | null;
+/**
+ * Why a pipeline cannot be archived, or `null` when it can.
+ *
+ * `openDeals` is the server's count, asked for before this is called, the
+ * way `stageRemovalRefusal` asks: an open deal in an archived pipeline is
+ * a card on no board, and the count is taken at the click because a deal
+ * can be created into the pipeline from another tab meanwhile. The default
+ * pipeline cannot go while it is the default — a new deal has to land
+ * somewhere — and the last active one cannot go at all, for the same
+ * reason from the other side.
+ */
+export declare function pipelineArchiveRefusal(pipeline: Pick<CrmPipeline, 'archivedAt' | 'isDefault'> & {
+    $id: string;
+}, pipelines: ReadonlyArray<Pick<CrmPipeline, 'archivedAt'> & {
+    $id: string;
+}>, openDeals: number): string | null;
+/** What every pipeline write stamps besides its name. */
+export interface PipelineWriteContext {
+    visibleTo: readonly string[];
+    hostId: string;
+    uid: string;
+    nowMs: number;
+}
+/**
+ * The document a new pipeline is created as: the name, a COPY of the
+ * default stages, not the default, active. A copy for the reason
+ * `DEFAULT_DEAL_STAGES` gives — a second pipeline seeded later must start
+ * from the original set, whatever the first one's editor did to its own.
+ */
+export declare function newPipelineDocument(name: string, context: PipelineWriteContext): Record<string, unknown>;
+/**
+ * Currencies the amount picker offers, lowercase ISO 4217 as the model
+ * stores them. Short on purpose: a picker of a hundred and eighty currencies
+ * is a scroll, and a deal in one outside this list is entered through the
+ * API with whatever code it carries — the display below formats any code
+ * `Intl` knows.
+ */
+export declare const DEAL_CURRENCIES: readonly ["usd", "eur", "gbp", "cad", "aud", "nzd", "chf", "jpy", "sek", "nok", "dkk", "mxn", "brl", "inr", "sgd"];
+export declare const DEFAULT_DEAL_CURRENCY = "usd";
+/** How a deal's `status` reads on screen. */
+export declare const DEAL_STATUS_LABELS: Record<CrmDeal['status'], string>;
+/** Cents → the reader's locale, or a plain number when the code is unknown. */
+export declare function formatMoney(cents: number, currency: string | undefined): string;
+/**
+ * A typed amount, as cents, or `null` when it is not a number.
+ *
+ * Accepts what people paste from an invoice — a thousands separator, a
+ * currency symbol, surrounding space — and refuses a negative: a deal is
+ * worth zero or more, and a negative amount here is a typo rather than a
+ * refund. Rounded rather than truncated so `19.995` does not lose a cent.
+ */
+export declare function parseAmountInput(input: string): number | null;
+/** Cents → the string the amount field shows, `''` for nothing. */
+export declare function amountInputValue(cents: number | undefined | null): string;
+/**
+ * Epoch ms from whatever a timestamp field holds after a round trip — a
+ * Firestore `Timestamp`, a `Date` a client just wrote, or a number.
+ */
+export declare function timestampMs(value: unknown): number | null;
+/** Whole days a deal has sat in its current stage, never negative. */
+export declare function daysInStage(deal: Pick<CrmDeal, 'stageChangedAtMs' | 'createdAt'>, nowMs: number): number;
+/** A sum per currency, because two currencies never add into one number. */
+export type AmountByCurrency = Record<string, number>;
+export interface BoardSummary {
+    /** Deals whose `status` is `open`, whatever stage they sit in. */
+    openCount: number;
+    /** Every open deal's full amount, per currency. */
+    valueByCurrency: AmountByCurrency;
+    /** Every open deal's amount times its stage's probability, per currency. */
+    weightedByCurrency: AmountByCurrency;
+}
+/**
+ * The three figures above the board.
+ *
+ * Closed deals are excluded from both totals rather than counted at full or
+ * zero value: the summary describes what is still in play, and a won deal
+ * counted in "pipeline value" would make the pipeline look larger every time
+ * something closed. `weightedDealAmountCents` already answers zero for a
+ * stage the pipeline no longer has.
+ */
+export declare function boardSummary(deals: readonly Pick<CrmDeal, 'status' | 'amountCents' | 'currency' | 'stageId'>[], pipeline: Pick<CrmPipeline, 'stages'> | null | undefined): BoardSummary;
+/** `$1,200.00 · €300.00` — one figure per currency, largest first. */
+export declare function formatAmountByCurrency(totals: AmountByCurrency): string;
+/** The pipeline's stages in `order`, ties broken by position. */
+export declare function sortedStages(pipeline: Pick<CrmPipeline, 'stages'> | null | undefined): CrmDealStage[];
+/** The stages a deal can be dragged between — everything that is not closed. */
+export declare function openStages(pipeline: Pick<CrmPipeline, 'stages'> | null | undefined): CrmDealStage[];
+/** The stage whose `kind` is `won` or `lost`, or null when the pipeline lacks one. */
+export declare function closingStage(pipeline: Pick<CrmPipeline, 'stages'> | null | undefined, kind: 'won' | 'lost'): CrmDealStage | null;
+/**
+ * The id a new stage is stored under: the name as a slug, made unique
+ * against the stages already there.
+ *
+ * A slug rather than a random id because the id appears in every deal that
+ * sits in the stage and in every automation filter that names it, so a
+ * reader looking at `stageId == "demo-booked"` should be able to tell which
+ * stage that is without opening the pipeline. Uniqueness is what keeps a
+ * second "Demo" from silently becoming the first.
+ */
+export declare function newStageId(name: string, existing: readonly CrmDealStage[]): string;
+/**
+ * Stages re-numbered 0..n in the order they are GIVEN.
+ *
+ * Positional on purpose: every caller hands this an array it has already
+ * arranged — a swap, a splice, a filter over the sorted stages — and the
+ * stored `order` on each entry is the arrangement being replaced. Sorting by
+ * it here would put a swapped pair straight back where it was.
+ */
+export declare function renumberStages(stages: readonly CrmDealStage[]): CrmDealStage[];
+/** 0–100, whole numbers; anything else becomes the nearest bound. */
+export declare function clampProbability(value: unknown): number;
+/**
+ * Add an open stage in front of the closing stages.
+ *
+ * Won and Lost stay last: a pipeline reads left to right as a progression,
+ * and a stage added after "Won" would be a step past the end.
+ */
+export declare function addStage(stages: readonly CrmDealStage[], name: string, probability?: number): CrmDealStage[];
+export declare function renameStage(stages: readonly CrmDealStage[], stageId: string, name: string): CrmDealStage[];
+/**
+ * Set an OPEN stage's probability. Won is 100 and Lost is 0 by definition —
+ * `weightedDealAmountCents` reads the status before the stage, so a Won
+ * stage at 60% would change nothing and only mislead the editor.
+ */
+export declare function setStageProbability(stages: readonly CrmDealStage[], stageId: string, probability: unknown): CrmDealStage[];
+/**
+ * Swap an open stage with its open neighbor. The closing stages are not in
+ * the reorderable range, so an open stage can never be moved past Won.
+ */
+export declare function moveStage(stages: readonly CrmDealStage[], stageId: string, direction: 'up' | 'down'): CrmDealStage[];
+/**
+ * Why a stage cannot be removed, or `null` when it can.
+ *
+ * `dealsInStage` is the server's count, asked for before this is called: a
+ * stage with deals in it cannot go, because every one of those deals would
+ * be left pointing at a stage that no longer exists and worth nothing to the
+ * forecast. The closing stages cannot go at all — a deal has to be able to
+ * be won and lost.
+ */
+export declare function stageRemovalRefusal(stages: readonly CrmDealStage[], stageId: string, dealsInStage: number): string | null;
+export declare function removeStage(stages: readonly CrmDealStage[], stageId: string): CrmDealStage[];
+/**
+ * What a stored set of stages has to satisfy before it is written back:
+ * unique ids, a name on every stage, exactly one Won and one Lost, at least
+ * one open stage. The editor refuses a save that fails this rather than
+ * writing a pipeline the board cannot draw.
+ */
+export declare function stagesProblem(stages: readonly CrmDealStage[]): string | null;
+/**
+ * The event a stage change emits, and the flat payload a workflow filter
+ * reads (AGL-2598). Strings and numbers only — a workflow expression
+ * evaluates over scalars, and an absent link is the empty string rather than
+ * a missing key so `contactId == ""` is a filter somebody can write.
+ */
+export type DealEventName = 'dealStageChanged' | 'dealWon' | 'dealLost';
+export declare function dealEventName(status: CrmDeal['status']): DealEventName;
+export declare function dealEventPayload(dealId: string, deal: Pick<CrmDeal, 'title' | 'amountCents' | 'currency' | 'stageId' | 'ownerUid' | 'contactId' | 'companyId' | 'lostReason'>, previousStageId: string): Record<string, string | number>;
+/** Initials for an avatar: the first letters of the first two words. */
+export declare function initialsFor(label: string): string;
+/**
+ * A stable hue for one person, so an owner keeps one color across cards and
+ * sessions. Hashing the label rather than picking from a palette is what
+ * makes the same uid the same color on every machine.
+ */
+export declare function hueFor(label: string): number;
+/** `2026-09-05` for a date input, from epoch ms; `''` for none. */
+export declare function dateInputValue(ms: number | null | undefined): string;
+/**
+ * Epoch ms at local noon of a typed `YYYY-MM-DD`, or `null`.
+ *
+ * Noon rather than midnight so the day survives a timezone round trip: a
+ * close date stored at local midnight and read back one timezone west shows
+ * the day before.
+ */
+export declare function dateInputMs(value: string): number | null;

package/src/lib/model/deal-board-model.js

@@ -0,0 +1,439 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @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 pipeline's arithmetic and the stage editor's rules (AGL-2598), as pure
+ * functions — no Firestore, no React — so the board, the table, the detail
+ * page and the server route read one definition of "what is this pipeline
+ * worth" and "which stage edits are legal".
+ */ // The module itself and never the `@aglyn/aglyn` barrel: this file is
+// reached from the server entry through the deal-stage route, and the barrel
+// carries client-only context modules the App Router graph refuses on a
+// server path (AGL-405/1349).
+import { DEFAULT_DEAL_STAGES, dealStageById, isPipelineArchived, weightedDealAmountCents } from "@aglyn/aglyn/app-utils/crm";
+/** The document id the seeded default pipeline is written under. */ export const DEFAULT_PIPELINE_ID = 'default';
+/** Name of the pipeline every org starts with. */ export const DEFAULT_PIPELINE_NAME = 'Sales';
+export const PIPELINE_NAME_MAX = 60;
+/** The pipelines a picker offers and a new deal may land in: the ones not archived. */ export function activePipelines(pipelines) {
+    return pipelines.filter((pipeline)=>!isPipelineArchived(pipeline));
+}
+/**
+ * The pipeline a new deal lands in when nobody picks one: the active one
+ * marked default, else the first active one, else nothing. An archived
+ * pipeline is never the default even if its flag was left on — archiving
+ * clears the flag, but a document written by an older console may not
+ * have had it cleared, and a default nobody can create a deal in is a
+ * board that opens on a pipeline the picker does not list.
+ */ export function defaultPipelineOf(pipelines) {
+    var _ref, _active_find;
+    const active = activePipelines(pipelines);
+    return (_ref = (_active_find = active.find((pipeline)=>pipeline.isDefault)) != null ? _active_find : active[0]) != null ? _ref : null;
+}
+/**
+ * Why a pipeline cannot be created or renamed to `name`, or `null`.
+ *
+ * Names are unique among the ACTIVE pipelines, compared without case: the
+ * picker lists them by name alone, and two rows reading "Sales" would be a
+ * choice nobody can make. An archived pipeline's name is free to reuse —
+ * "Sales 2025" retired and "Sales" started over is the point of archiving.
+ */ export function pipelineNameProblem(name, pipelines, ownId) {
+    const trimmed = String(name != null ? name : '').trim();
+    if (!trimmed) return 'A pipeline needs a name.';
+    const taken = activePipelines(pipelines).find((pipeline)=>{
+        var _pipeline_name;
+        return pipeline.$id !== ownId && String((_pipeline_name = pipeline.name) != null ? _pipeline_name : '').trim().toLowerCase() === trimmed.toLowerCase();
+    });
+    if (taken) return `Another pipeline is already called "${taken.name}".`;
+    return null;
+}
+/**
+ * Why a pipeline cannot be archived, or `null` when it can.
+ *
+ * `openDeals` is the server's count, asked for before this is called, the
+ * way `stageRemovalRefusal` asks: an open deal in an archived pipeline is
+ * a card on no board, and the count is taken at the click because a deal
+ * can be created into the pipeline from another tab meanwhile. The default
+ * pipeline cannot go while it is the default — a new deal has to land
+ * somewhere — and the last active one cannot go at all, for the same
+ * reason from the other side.
+ */ export function pipelineArchiveRefusal(pipeline, pipelines, openDeals) {
+    if (isPipelineArchived(pipeline)) return 'This pipeline is already archived.';
+    if (activePipelines(pipelines).filter((entry)=>entry.$id !== pipeline.$id).length === 0) {
+        return 'The last pipeline cannot be archived.';
+    }
+    if (pipeline.isDefault) {
+        return 'This is the default pipeline. Make another one the default first.';
+    }
+    if (openDeals > 0) {
+        return `${openDeals.toLocaleString()} open ${openDeals === 1 ? 'deal is' : 'deals are'} ` + 'in this pipeline. Close or move them first, so none is left on a board nobody opens.';
+    }
+    return null;
+}
+/**
+ * The document a new pipeline is created as: the name, a COPY of the
+ * default stages, not the default, active. A copy for the reason
+ * `DEFAULT_DEAL_STAGES` gives — a second pipeline seeded later must start
+ * from the original set, whatever the first one's editor did to its own.
+ */ export function newPipelineDocument(name, context) {
+    return {
+        name: String(name != null ? name : '').trim().slice(0, PIPELINE_NAME_MAX),
+        stages: DEFAULT_DEAL_STAGES.map((stage)=>_extends({}, stage)),
+        isDefault: false,
+        archivedAt: null,
+        visibleTo: [
+            ...context.visibleTo
+        ],
+        hostId: context.hostId,
+        createdByUid: context.uid,
+        createdAt: new Date(context.nowMs),
+        updatedAt: new Date(context.nowMs)
+    };
+}
+/**
+ * Currencies the amount picker offers, lowercase ISO 4217 as the model
+ * stores them. Short on purpose: a picker of a hundred and eighty currencies
+ * is a scroll, and a deal in one outside this list is entered through the
+ * API with whatever code it carries — the display below formats any code
+ * `Intl` knows.
+ */ export const DEAL_CURRENCIES = [
+    'usd',
+    'eur',
+    'gbp',
+    'cad',
+    'aud',
+    'nzd',
+    'chf',
+    'jpy',
+    'sek',
+    'nok',
+    'dkk',
+    'mxn',
+    'brl',
+    'inr',
+    'sgd'
+];
+export const DEFAULT_DEAL_CURRENCY = 'usd';
+/** How a deal's `status` reads on screen. */ export const DEAL_STATUS_LABELS = {
+    open: 'Open',
+    won: 'Won',
+    lost: 'Lost'
+};
+/** Cents → the reader's locale, or a plain number when the code is unknown. */ export function formatMoney(cents, currency) {
+    const code = String(currency || DEFAULT_DEAL_CURRENCY).toUpperCase();
+    const amount = (Number(cents) || 0) / 100;
+    try {
+        return new Intl.NumberFormat(undefined, {
+            style: 'currency',
+            currency: code
+        }).format(amount);
+    } catch (unused) {
+        return `${amount.toFixed(2)} ${code}`;
+    }
+}
+/**
+ * A typed amount, as cents, or `null` when it is not a number.
+ *
+ * Accepts what people paste from an invoice — a thousands separator, a
+ * currency symbol, surrounding space — and refuses a negative: a deal is
+ * worth zero or more, and a negative amount here is a typo rather than a
+ * refund. Rounded rather than truncated so `19.995` does not lose a cent.
+ */ export function parseAmountInput(input) {
+    const cleaned = String(input != null ? input : '').replace(/[^0-9.-]/g, '').trim();
+    if (!cleaned) return null;
+    const value = Number(cleaned);
+    if (!Number.isFinite(value) || value < 0) return null;
+    return Math.round(value * 100);
+}
+/** Cents → the string the amount field shows, `''` for nothing. */ export function amountInputValue(cents) {
+    if (typeof cents !== 'number' || !Number.isFinite(cents)) return '';
+    return (cents / 100).toFixed(2);
+}
+/**
+ * Epoch ms from whatever a timestamp field holds after a round trip — a
+ * Firestore `Timestamp`, a `Date` a client just wrote, or a number.
+ */ export function timestampMs(value) {
+    if (!value) return null;
+    if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+    if (value instanceof Date) return value.getTime();
+    const seconds = value.seconds;
+    if (typeof seconds === 'number') return seconds * 1000;
+    const toMillis = value.toMillis;
+    if (typeof toMillis === 'function') return toMillis.call(value);
+    return null;
+}
+/** Whole days a deal has sat in its current stage, never negative. */ export function daysInStage(deal, nowMs) {
+    const since = typeof deal.stageChangedAtMs === 'number' ? deal.stageChangedAtMs : timestampMs(deal.createdAt);
+    if (!since) return 0;
+    return Math.max(0, Math.floor((nowMs - since) / 86400000));
+}
+function addAmount(totals, currency, cents) {
+    var _totals_code;
+    const code = String(currency || DEFAULT_DEAL_CURRENCY).toLowerCase();
+    totals[code] = ((_totals_code = totals[code]) != null ? _totals_code : 0) + cents;
+}
+/**
+ * The three figures above the board.
+ *
+ * Closed deals are excluded from both totals rather than counted at full or
+ * zero value: the summary describes what is still in play, and a won deal
+ * counted in "pipeline value" would make the pipeline look larger every time
+ * something closed. `weightedDealAmountCents` already answers zero for a
+ * stage the pipeline no longer has.
+ */ export function boardSummary(deals, pipeline) {
+    const summary = {
+        openCount: 0,
+        valueByCurrency: {},
+        weightedByCurrency: {}
+    };
+    for (const deal of deals){
+        var _deal_amountCents;
+        if (deal.status !== 'open') continue;
+        summary.openCount += 1;
+        const amount = Math.max(0, Math.round(Number((_deal_amountCents = deal.amountCents) != null ? _deal_amountCents : 0) || 0));
+        addAmount(summary.valueByCurrency, deal.currency, amount);
+        addAmount(summary.weightedByCurrency, deal.currency, weightedDealAmountCents(deal, dealStageById(pipeline, deal.stageId)));
+    }
+    return summary;
+}
+/** `$1,200.00 · €300.00` — one figure per currency, largest first. */ export function formatAmountByCurrency(totals) {
+    const entries = Object.entries(totals).sort((a, b)=>b[1] - a[1]);
+    if (!entries.length) return formatMoney(0, DEFAULT_DEAL_CURRENCY);
+    return entries.map(([code, cents])=>formatMoney(cents, code)).join(' · ');
+}
+/** The pipeline's stages in `order`, ties broken by position. */ export function sortedStages(pipeline) {
+    var _ref;
+    return [
+        ...(_ref = pipeline == null ? void 0 : pipeline.stages) != null ? _ref : []
+    ].map((stage, index)=>({
+            stage,
+            index
+        })).sort((a, b)=>a.stage.order - b.stage.order || a.index - b.index).map(({ stage })=>stage);
+}
+/** The stages a deal can be dragged between — everything that is not closed. */ export function openStages(pipeline) {
+    return sortedStages(pipeline).filter((stage)=>stage.kind === 'open');
+}
+/** The stage whose `kind` is `won` or `lost`, or null when the pipeline lacks one. */ export function closingStage(pipeline, kind) {
+    var _sortedStages_find;
+    return (_sortedStages_find = sortedStages(pipeline).find((stage)=>stage.kind === kind)) != null ? _sortedStages_find : null;
+}
+/**
+ * The id a new stage is stored under: the name as a slug, made unique
+ * against the stages already there.
+ *
+ * A slug rather than a random id because the id appears in every deal that
+ * sits in the stage and in every automation filter that names it, so a
+ * reader looking at `stageId == "demo-booked"` should be able to tell which
+ * stage that is without opening the pipeline. Uniqueness is what keeps a
+ * second "Demo" from silently becoming the first.
+ */ export function newStageId(name, existing) {
+    const base = String(name != null ? name : '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'stage';
+    const taken = new Set(existing.map((stage)=>stage.id));
+    if (!taken.has(base)) return base;
+    let suffix = 2;
+    while(taken.has(`${base}-${suffix}`))suffix += 1;
+    return `${base}-${suffix}`;
+}
+/**
+ * Stages re-numbered 0..n in the order they are GIVEN.
+ *
+ * Positional on purpose: every caller hands this an array it has already
+ * arranged — a swap, a splice, a filter over the sorted stages — and the
+ * stored `order` on each entry is the arrangement being replaced. Sorting by
+ * it here would put a swapped pair straight back where it was.
+ */ export function renumberStages(stages) {
+    return stages.map((stage, order)=>_extends({}, stage, {
+            order
+        }));
+}
+/** 0–100, whole numbers; anything else becomes the nearest bound. */ export function clampProbability(value) {
+    const number = Math.round(Number(value));
+    if (!Number.isFinite(number)) return 0;
+    return Math.min(100, Math.max(0, number));
+}
+/**
+ * Add an open stage in front of the closing stages.
+ *
+ * Won and Lost stay last: a pipeline reads left to right as a progression,
+ * and a stage added after "Won" would be a step past the end.
+ */ export function addStage(stages, name, probability = 50) {
+    const trimmed = String(name != null ? name : '').trim();
+    if (!trimmed) return [
+        ...stages
+    ];
+    const sorted = sortedStages({
+        stages: [
+            ...stages
+        ]
+    });
+    const firstClosed = sorted.findIndex((stage)=>stage.kind !== 'open');
+    const at = firstClosed === -1 ? sorted.length : firstClosed;
+    const stage = {
+        id: newStageId(trimmed, sorted),
+        name: trimmed,
+        order: at,
+        probability: clampProbability(probability),
+        kind: 'open'
+    };
+    sorted.splice(at, 0, stage);
+    return renumberStages(sorted);
+}
+export function renameStage(stages, stageId, name) {
+    const trimmed = String(name != null ? name : '').trim();
+    return stages.map((stage)=>stage.id === stageId && trimmed ? _extends({}, stage, {
+            name: trimmed
+        }) : stage);
+}
+/**
+ * Set an OPEN stage's probability. Won is 100 and Lost is 0 by definition —
+ * `weightedDealAmountCents` reads the status before the stage, so a Won
+ * stage at 60% would change nothing and only mislead the editor.
+ */ export function setStageProbability(stages, stageId, probability) {
+    return stages.map((stage)=>stage.id === stageId && stage.kind === 'open' ? _extends({}, stage, {
+            probability: clampProbability(probability)
+        }) : stage);
+}
+/**
+ * Swap an open stage with its open neighbor. The closing stages are not in
+ * the reorderable range, so an open stage can never be moved past Won.
+ */ export function moveStage(stages, stageId, direction) {
+    const sorted = sortedStages({
+        stages: [
+            ...stages
+        ]
+    });
+    const index = sorted.findIndex((stage)=>stage.id === stageId);
+    if (index === -1 || sorted[index].kind !== 'open') return sorted;
+    const target = direction === 'up' ? index - 1 : index + 1;
+    if (target < 0 || target >= sorted.length) return sorted;
+    if (sorted[target].kind !== 'open') return sorted;
+    const swapped = [
+        ...sorted
+    ];
+    const moving = swapped[index];
+    swapped[index] = swapped[target];
+    swapped[target] = moving;
+    return renumberStages(swapped);
+}
+/**
+ * Why a stage cannot be removed, or `null` when it can.
+ *
+ * `dealsInStage` is the server's count, asked for before this is called: a
+ * stage with deals in it cannot go, because every one of those deals would
+ * be left pointing at a stage that no longer exists and worth nothing to the
+ * forecast. The closing stages cannot go at all — a deal has to be able to
+ * be won and lost.
+ */ export function stageRemovalRefusal(stages, stageId, dealsInStage) {
+    const stage = stages.find((entry)=>entry.id === stageId);
+    if (!stage) return 'This stage is no longer in the pipeline.';
+    if (stage.kind !== 'open') {
+        return `Every pipeline keeps its ${stage.kind === 'won' ? 'Won' : 'Lost'} stage.`;
+    }
+    if (openStages({
+        stages: [
+            ...stages
+        ]
+    }).length <= 1) {
+        return 'A pipeline needs at least one open stage.';
+    }
+    if (dealsInStage > 0) {
+        return `${dealsInStage.toLocaleString()} ${dealsInStage === 1 ? 'deal is' : 'deals are'} ` + 'in this stage. Move them first, so none is left in a stage that no longer exists.';
+    }
+    return null;
+}
+export function removeStage(stages, stageId) {
+    return renumberStages(stages.filter((stage)=>stage.id !== stageId));
+}
+/**
+ * What a stored set of stages has to satisfy before it is written back:
+ * unique ids, a name on every stage, exactly one Won and one Lost, at least
+ * one open stage. The editor refuses a save that fails this rather than
+ * writing a pipeline the board cannot draw.
+ */ export function stagesProblem(stages) {
+    if (!stages.length) return 'A pipeline needs stages.';
+    const ids = new Set();
+    for (const stage of stages){
+        var _stage_name;
+        if (!stage.id) return 'Every stage needs an id.';
+        if (ids.has(stage.id)) return `Two stages share the id "${stage.id}".`;
+        ids.add(stage.id);
+        if (!String((_stage_name = stage.name) != null ? _stage_name : '').trim()) return 'Every stage needs a name.';
+    }
+    const won = stages.filter((stage)=>stage.kind === 'won').length;
+    const lost = stages.filter((stage)=>stage.kind === 'lost').length;
+    if (won !== 1) return 'A pipeline has exactly one Won stage.';
+    if (lost !== 1) return 'A pipeline has exactly one Lost stage.';
+    if (!stages.some((stage)=>stage.kind === 'open')) {
+        return 'A pipeline needs at least one open stage.';
+    }
+    return null;
+}
+export function dealEventName(status) {
+    if (status === 'won') return 'dealWon';
+    if (status === 'lost') return 'dealLost';
+    return 'dealStageChanged';
+}
+export function dealEventPayload(dealId, deal, previousStageId) {
+    var _deal_title, _deal_amountCents, _deal_stageId, _deal_ownerUid, _deal_contactId, _deal_companyId;
+    return _extends({
+        dealId,
+        title: String((_deal_title = deal.title) != null ? _deal_title : ''),
+        amountCents: Math.max(0, Math.round(Number((_deal_amountCents = deal.amountCents) != null ? _deal_amountCents : 0) || 0)),
+        currency: String(deal.currency || DEFAULT_DEAL_CURRENCY).toLowerCase(),
+        stageId: String((_deal_stageId = deal.stageId) != null ? _deal_stageId : ''),
+        previousStageId: String(previousStageId != null ? previousStageId : ''),
+        ownerUid: String((_deal_ownerUid = deal.ownerUid) != null ? _deal_ownerUid : ''),
+        contactId: String((_deal_contactId = deal.contactId) != null ? _deal_contactId : ''),
+        companyId: String((_deal_companyId = deal.companyId) != null ? _deal_companyId : '')
+    }, deal.lostReason ? {
+        lostReason: String(deal.lostReason)
+    } : {});
+}
+/** Initials for an avatar: the first letters of the first two words. */ export function initialsFor(label) {
+    const words = String(label != null ? label : '').trim().split(/[\s@._-]+/).filter(Boolean);
+    const letters = words.slice(0, 2).map((word)=>word[0]).join('');
+    return (letters || '?').toUpperCase();
+}
+/**
+ * A stable hue for one person, so an owner keeps one color across cards and
+ * sessions. Hashing the label rather than picking from a palette is what
+ * makes the same uid the same color on every machine.
+ */ export function hueFor(label) {
+    let hash = 0;
+    for(let index = 0; index < label.length; index += 1){
+        hash = (hash * 31 + label.charCodeAt(index)) % 360;
+    }
+    return hash;
+}
+/** `2026-09-05` for a date input, from epoch ms; `''` for none. */ export function dateInputValue(ms) {
+    if (typeof ms !== 'number' || !Number.isFinite(ms)) return '';
+    const at = new Date(ms);
+    const offset = at.getTimezoneOffset() * 60000;
+    return new Date(ms - offset).toISOString().slice(0, 10);
+}
+/**
+ * Epoch ms at local noon of a typed `YYYY-MM-DD`, or `null`.
+ *
+ * Noon rather than midnight so the day survives a timezone round trip: a
+ * close date stored at local midnight and read back one timezone west shows
+ * the day before.
+ */ export function dateInputMs(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(value != null ? value : '').trim());
+    if (!match) return null;
+    const at = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]), 12, 0, 0, 0);
+    return Number.isNaN(at.getTime()) ? null : at.getTime();
+}
+
+//# sourceMappingURL=deal-board-model.js.map