@aglyn/plugins-crm 1.0.0-beta.217 → 1.0.0-beta.219

package/src/lib/model/crm-sharing.js

@@ -0,0 +1,603 @@
+/**
+ * @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.
+ */ /**
+ * CRM SHARING FOR MULTI-BRAND ORGS (AGL-3336).
+ *
+ * An org manager shares a lead, a contact, a company or a deal with other
+ * sites — by hand, from the record or a list's bulk bar, or by a SHARING
+ * RULE that applies to every record it matches, now and later. The model is
+ * Salesforce's three layers:
+ *
+ * 1. the org-wide default — the consent-group scope a record is captured
+ *    with (`consentGroupScope`), untouched by anything here;
+ * 2. sharing rules — `crm.sharingRules` on the org document;
+ * 3. manual shares — per record, per target.
+ *
+ * ## One field is enforced, so one field is widened
+ *
+ * Both enforcement layers read `visibleTo`: the rules with `hasAny`, every
+ * list with `array-contains-any`. A share therefore ADDS its tokens to
+ * `visibleTo`, which is what puts the record on the target site's lists as a
+ * real query — no second field, no second index, no loaded-window match.
+ * `'org'` is the token for "all sites", and it covers a site created later
+ * with nothing to recompute, because every site's read set carries it.
+ *
+ * ## …and the sources stay distinguishable
+ *
+ * The record keeps its grants under `sharing` (`SCOPE_GRANTS_FIELD` in
+ * core): one grant per rule and one per hand-shared target, and `added`,
+ * the tokens the grants put on `visibleTo` that were not there already.
+ * The record's own scope — its HELD tokens — is `visibleTo` without
+ * `added`, so taking a grant away removes only what grants alone
+ * contributed, and never a consent-group token. A token a site later
+ * captures the person on is held from then on: the capturing sites
+ * (`hostId`, `capturedByHostIds`) are never counted as added.
+ *
+ * ## Visibility is not consent, and not write access
+ *
+ * Nothing here reads or writes a consent entry. A site a record is shared
+ * with sees it; it holds no basis to market to the person, and the
+ * audience paths read `heldByHost`, not `visibleTo`. Write access is its
+ * own field, `writeTo`, present only on a shared record: the held tokens
+ * and the tokens of grants whose access is `edit`. The Firestore rules and
+ * the CRM's routes check it; a read-only grant is the default.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { heldScopeTokens, hostIdsFromScope, hostScopeToken, isScopeToken, MAX_SCOPE_HOSTS, ORG_SCOPE_TOKEN, parseScopeToken, SCOPE_GRANTS_FIELD } from "@aglyn/aglyn/app-utils/scope-tokens";
+/*==========================================
+ * WHAT IS SHARED.
+ *=========================================*/ /** The four record types a share or a rule applies to, by their collection. */ export const CRM_SHARING_OBJECTS = [
+    'leads',
+    'contacts',
+    'companies',
+    'deals'
+];
+export function isCrmSharingObject(value) {
+    return typeof value === 'string' && CRM_SHARING_OBJECTS.includes(value);
+}
+/** How each object reads in a sentence. */ export const CRM_SHARING_OBJECT_LABELS = {
+    leads: {
+        one: 'lead',
+        many: 'Leads'
+    },
+    contacts: {
+        one: 'contact',
+        many: 'Contacts'
+    },
+    companies: {
+        one: 'company',
+        many: 'Companies'
+    },
+    deals: {
+        one: 'deal',
+        many: 'Deals'
+    }
+};
+export function isCrmShareAccess(value) {
+    return value === 'read' || value === 'edit';
+}
+/** The record field its grants live under — the core's name for it. */ export const CRM_SHARING_FIELD = SCOPE_GRANTS_FIELD;
+/** The record field naming who may WRITE it, present only while it is shared. */ export const CRM_WRITE_SCOPE_FIELD = 'writeTo';
+/** The array field a rule's removal queries. */ export const CRM_SHARING_RULE_IDS_PATH = `${CRM_SHARING_FIELD}.ruleIds`;
+/** A hand share is one grant per target, so each is unshared on its own. */ export function manualGrantKey(token) {
+    const parsed = parseScopeToken(token);
+    if (!parsed) throw new Error(`not a scope token: ${token}`);
+    return parsed.kind === 'org' ? 'manual_org' : `manual_${parsed.hostId}`;
+}
+export function ruleGrantKey(ruleId) {
+    return `rule_${ruleId}`;
+}
+function tokenList(raw) {
+    if (!Array.isArray(raw)) return [];
+    return [
+        ...new Set(raw.filter(isScopeToken))
+    ];
+}
+function readGrant(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const value = raw;
+    const tokens = tokenList(value['tokens']);
+    if (!tokens.length) return null;
+    const source = value['source'] === 'rule' ? 'rule' : value['source'] === 'manual' ? 'manual' : null;
+    if (!source) return null;
+    const ruleId = typeof value['ruleId'] === 'string' ? value['ruleId'] : '';
+    if (source === 'rule' && !ruleId) return null;
+    const byUid = typeof value['byUid'] === 'string' ? value['byUid'] : '';
+    const byName = typeof value['byName'] === 'string' ? value['byName'] : '';
+    const atMs = typeof value['atMs'] === 'number' && Number.isFinite(value['atMs']) ? value['atMs'] : 0;
+    return _extends({
+        source,
+        tokens,
+        access: value['access'] === 'edit' ? 'edit' : 'read'
+    }, ruleId ? {
+        ruleId
+    } : {}, byUid ? {
+        byUid
+    } : {}, byName ? {
+        byName
+    } : {}, {
+        atMs
+    });
+}
+/** A record's grants, cleaned; `{}` for a record never shared. */ export function readRecordGrants(record) {
+    const sharing = (record != null ? record : {})[CRM_SHARING_FIELD];
+    if (!sharing || typeof sharing !== 'object' || Array.isArray(sharing)) return {};
+    const grants = sharing['grants'];
+    if (!grants || typeof grants !== 'object' || Array.isArray(grants)) return {};
+    const out = {};
+    for (const [key, raw] of Object.entries(grants)){
+        const grant = readGrant(raw);
+        if (grant) out[key] = grant;
+    }
+    return out;
+}
+/*==========================================
+ * THE PLAN: grants in, the three fields out.
+ *=========================================*/ /**
+ * The sites that captured or created the record. Their tokens are HELD,
+ * whatever `added` says: a person shared to site B and later captured on B
+ * is B's own from then on, and unsharing must not hide them from B.
+ */ export function recordHolderHostIds(record) {
+    const ids = new Set();
+    const hostId = record['hostId'];
+    if (typeof hostId === 'string' && hostId) ids.add(hostId);
+    const captured = record['capturedByHostIds'];
+    if (Array.isArray(captured)) {
+        for (const id of captured)if (typeof id === 'string' && id) ids.add(id);
+    }
+    return [
+        ...ids
+    ];
+}
+/**
+ * The record's own scope: `visibleTo` less what grants added, its capturing
+ * sites kept — the core's `heldScopeTokens`, as scope tokens.
+ */ export function recordHeldScope(record) {
+    return tokenList(heldScopeTokens(record));
+}
+/**
+ * The fields a record carries under `grants`.
+ *
+ * A grant naming a token the record already holds adds nothing, and a
+ * record held org-wide adds nothing at all — every site sees it already, so
+ * a share there would only make a later unshare look like it hid something.
+ * The token order is the held scope first and the additions after it, so an
+ * unchanged record plans the `visibleTo` it has.
+ */ export function planRecordSharing(record, grants) {
+    const held = recordHeldScope(record);
+    const entries = Object.entries(grants);
+    if (!entries.length) return {
+        visibleTo: held,
+        writeTo: null,
+        sharing: null
+    };
+    const heldSet = new Set(held);
+    const heldOrgWide = heldSet.has(ORG_SCOPE_TOKEN);
+    const tokens = [];
+    const editTokens = [];
+    const ruleIds = [];
+    for (const [, grant] of entries.sort(([a], [b])=>a < b ? -1 : a > b ? 1 : 0)){
+        for (const token of grant.tokens){
+            if (!tokens.includes(token)) tokens.push(token);
+            if (grant.access === 'edit' && !editTokens.includes(token)) editTokens.push(token);
+        }
+        if (grant.source === 'rule' && grant.ruleId && !ruleIds.includes(grant.ruleId)) {
+            ruleIds.push(grant.ruleId);
+        }
+    }
+    const added = heldOrgWide ? [] : tokens.filter((token)=>!heldSet.has(token));
+    const writeTo = [
+        ...held
+    ];
+    for (const token of editTokens)if (!writeTo.includes(token)) writeTo.push(token);
+    return {
+        visibleTo: [
+            ...held,
+            ...added
+        ],
+        writeTo,
+        sharing: {
+            grants: Object.fromEntries(entries),
+            tokens,
+            added,
+            ruleIds,
+            orgWideHeldBy: added.includes(ORG_SCOPE_TOKEN) ? [
+                ...held
+            ] : []
+        }
+    };
+}
+const sameList = (a, b)=>(a != null ? a : null) === null ? (b != null ? b : null) === null : (b != null ? b : null) !== null && a.length === b.length && a.every((entry, at)=>entry === b[at]);
+const sameGrant = (a, b)=>{
+    var _a_ruleId, _b_ruleId, _a_byUid, _b_byUid, _a_byName, _b_byName;
+    return !!a && !!b && a.source === b.source && a.access === b.access && ((_a_ruleId = a.ruleId) != null ? _a_ruleId : '') === ((_b_ruleId = b.ruleId) != null ? _b_ruleId : '') && ((_a_byUid = a.byUid) != null ? _a_byUid : '') === ((_b_byUid = b.byUid) != null ? _b_byUid : '') && ((_a_byName = a.byName) != null ? _a_byName : '') === ((_b_byName = b.byName) != null ? _b_byName : '') && a.atMs === b.atMs && sameList(a.tokens, b.tokens);
+};
+/** Whether writing `plan` would change what the record stores. */ export function sharingPlanChanges(record, plan) {
+    if (!sameList(tokenList(record['visibleTo']), plan.visibleTo)) return true;
+    const storedWrite = record[CRM_WRITE_SCOPE_FIELD];
+    if (!sameList(Array.isArray(storedWrite) ? tokenList(storedWrite) : null, plan.writeTo)) return true;
+    const stored = record[CRM_SHARING_FIELD];
+    if (!plan.sharing) return stored !== undefined && stored !== null;
+    const grants = readRecordGrants(record);
+    const keys = Object.keys(plan.sharing.grants);
+    if (keys.length !== Object.keys(grants).length) return true;
+    if (!keys.every((key)=>sameGrant(grants[key], plan.sharing.grants[key]))) return true;
+    const sharing = stored != null ? stored : {};
+    return !sameList(tokenList(sharing['tokens']), plan.sharing.tokens) || !sameList(tokenList(sharing['added']), plan.sharing.added) || !sameList(Array.isArray(sharing['ruleIds']) ? sharing['ruleIds'] : [], plan.sharing.ruleIds) || !sameList(tokenList(sharing['orgWideHeldBy']), plan.sharing.orgWideHeldBy);
+}
+/*==========================================
+ * SHARING RULES: `crm.sharingRules` on the org document.
+ *=========================================*/ /** The org document path the rules are stored under. */ export const CRM_SHARING_RULES_PATH = 'crm.sharingRules';
+/** A workspace keeps at most this many. */ export const CRM_SHARING_RULES_MAX = 20;
+/** At most this many values per criterion. */ export const CRM_SHARING_CRITERION_MAX = 20;
+export const CRM_SHARING_CRITERIA_KEYS = [
+    'leadSources',
+    'tags',
+    'campaignIds',
+    'stages',
+    'ownerUids'
+];
+/** Which criteria an object's records can answer. */ export const CRM_SHARING_CRITERIA_FOR = {
+    leads: [
+        'leadSources',
+        'tags',
+        'campaignIds',
+        'stages',
+        'ownerUids'
+    ],
+    contacts: [
+        'leadSources',
+        'tags',
+        'campaignIds',
+        'stages',
+        'ownerUids'
+    ],
+    companies: [
+        'tags',
+        'ownerUids'
+    ],
+    deals: [
+        'stages',
+        'ownerUids'
+    ]
+};
+const RULE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+function stringList(raw, max = CRM_SHARING_CRITERION_MAX) {
+    if (!Array.isArray(raw)) return [];
+    const out = [];
+    for (const entry of raw){
+        const value = String(entry != null ? entry : '').trim().slice(0, 200);
+        if (value && !out.includes(value)) out.push(value);
+        if (out.length >= max) break;
+    }
+    return out;
+}
+/** One rule as stored, cleaned, or null when it cannot be applied. */ export function readCrmSharingRule(raw) {
+    var _value_id, _value_criteria, _value_name;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const value = raw;
+    const id = String((_value_id = value['id']) != null ? _value_id : '');
+    if (!RULE_ID.test(id)) return null;
+    if (!isCrmSharingObject(value['object'])) return null;
+    const targets = normalizeShareTargets(tokenList(value['targets']));
+    if (!targets) return null;
+    const rawCriteria = (_value_criteria = value['criteria']) != null ? _value_criteria : {};
+    const criteria = {};
+    for (const key of CRM_SHARING_CRITERIA_FOR[value['object']]){
+        const list = stringList(rawCriteria[key]);
+        if (list.length) criteria[key] = key === 'tags' ? list.map((tag)=>tag.toLowerCase()) : list;
+    }
+    const run = value['run'];
+    return _extends({
+        id,
+        name: String((_value_name = value['name']) != null ? _value_name : '').trim().slice(0, 120) || 'Sharing rule',
+        object: value['object'],
+        enabled: value['enabled'] !== false,
+        sourceHostIds: stringList(value['sourceHostIds'], MAX_SCOPE_HOSTS),
+        criteria,
+        targets,
+        access: value['access'] === 'edit' ? 'edit' : 'read'
+    }, value['deleting'] === true ? {
+        deleting: true
+    } : {}, typeof value['createdByUid'] === 'string' ? {
+        createdByUid: value['createdByUid']
+    } : {}, {
+        createdAtMs: Number(value['createdAtMs']) || 0,
+        updatedAtMs: Number(value['updatedAtMs']) || 0
+    }, run && typeof run === 'object' ? {
+        run: _extends({
+            status: run['status'] === 'done' || run['status'] === 'failed' ? run['status'] : 'running',
+            mode: run['mode'] === 'remove' ? 'remove' : 'apply',
+            processed: Number(run['processed']) || 0,
+            changed: Number(run['changed']) || 0,
+            cursor: typeof run['cursor'] === 'string' ? run['cursor'] : null,
+            startedAtMs: Number(run['startedAtMs']) || 0
+        }, typeof run['finishedAtMs'] === 'number' ? {
+            finishedAtMs: run['finishedAtMs']
+        } : {}, typeof run['error'] === 'string' ? {
+            error: run['error']
+        } : {})
+    } : {});
+}
+/** The org's sharing rules, in their stored order. */ export function readCrmSharingRules(org) {
+    const crm = (org != null ? org : {})['crm'];
+    const raw = crm && typeof crm === 'object' && !Array.isArray(crm) ? crm['sharingRules'] : undefined;
+    if (!Array.isArray(raw)) return [];
+    const out = [];
+    for (const entry of raw){
+        const rule = readCrmSharingRule(entry);
+        if (rule && !out.some((existing)=>existing.id === rule.id)) out.push(rule);
+    }
+    return out;
+}
+/** The rules that grant anything now: enabled, and not being deleted. */ export function activeSharingRules(rules, object) {
+    return rules.filter((rule)=>rule.enabled && !rule.deleting && (!object || rule.object === object));
+}
+/**
+ * A share's targets, cleaned for storage: `['org']` when all sites are
+ * named, else the host tokens, capped. `null` when nothing is left.
+ */ export function normalizeShareTargets(tokens) {
+    const clean = tokenList(tokens);
+    if (!clean.length) return null;
+    if (clean.includes(ORG_SCOPE_TOKEN)) return [
+        ORG_SCOPE_TOKEN
+    ];
+    if (clean.length > MAX_SCOPE_HOSTS) return null;
+    return clean;
+}
+/** Targets from a request: `'all'`, or a list of host ids. */ export function shareTargetsFrom(input) {
+    if (input === 'all') return [
+        ORG_SCOPE_TOKEN
+    ];
+    if (!Array.isArray(input)) return null;
+    return normalizeShareTargets(input.map((id)=>String(id != null ? id : '').trim()).filter((id)=>id && !id.includes('/') && !id.includes(':')).map(hostScopeToken));
+}
+const str = (value)=>typeof value === 'string' ? value.trim() : '';
+const strs = (value)=>Array.isArray(value) ? value.map(str).filter(Boolean) : [];
+/**
+ * The facts a rule's criteria are matched against. A contact keeps each
+ * holder's working fields in its own facet, so a contact answers with the
+ * union of its facets: a rule about "contacts tagged vip" matches a person
+ * any holder tagged.
+ */ export function crmSharingFacts(object, record) {
+    const facts = {
+        hostIds: recordHolderHostIds(record),
+        leadSources: [],
+        tags: [],
+        campaignIds: [],
+        stages: [],
+        ownerUids: []
+    };
+    const take = (source, stageField)=>{
+        const leadSource = str(source['leadSource']);
+        if (leadSource) facts.leadSources.push(leadSource);
+        facts.tags.push(...strs(source['tags']).map((tag)=>tag.toLowerCase()));
+        facts.campaignIds.push(...strs(source['campaignIds']));
+        const stage = stageField ? str(source[stageField]) : '';
+        if (stage) facts.stages.push(stage);
+        const owner = str(source['ownerUid']);
+        if (owner) facts.ownerUids.push(owner);
+    };
+    if (object === 'leads') take(record, 'status');
+    else if (object === 'companies') take(record, null);
+    else if (object === 'deals') take(record, 'stageId');
+    else {
+        const facets = record['facets'];
+        if (facets && typeof facets === 'object' && !Array.isArray(facets)) {
+            for (const facet of Object.values(facets)){
+                if (facet && typeof facet === 'object' && !Array.isArray(facet)) {
+                    take(facet, 'lifecycleStage');
+                }
+            }
+        }
+    }
+    // A lead with no status is New, as every lead reader answers it.
+    if (object === 'leads' && !facts.stages.length) facts.stages.push('new');
+    return facts;
+}
+const anyOf = (wanted, have, fold = false)=>{
+    if (!(wanted == null ? void 0 : wanted.length)) return true;
+    const set = new Set(fold ? have.map((value)=>value.toLowerCase()) : have);
+    return wanted.some((value)=>set.has(fold ? value.toLowerCase() : value));
+};
+/** Whether a rule shares this record. */ export function crmSharingRuleMatches(rule, object, record) {
+    if (!rule.enabled || rule.deleting || rule.object !== object) return false;
+    const facts = crmSharingFacts(object, record);
+    if (rule.sourceHostIds.length && !facts.hostIds.some((id)=>rule.sourceHostIds.includes(id))) {
+        return false;
+    }
+    const { criteria } = rule;
+    return anyOf(criteria.leadSources, facts.leadSources, true) && anyOf(criteria.tags, facts.tags, true) && anyOf(criteria.campaignIds, facts.campaignIds) && anyOf(criteria.stages, facts.stages) && anyOf(criteria.ownerUids, facts.ownerUids);
+}
+/**
+ * The grants a record should carry: its hand shares as they are, and one
+ * grant per active rule that matches it now. A rule grant already present
+ * keeps its date, so re-evaluating an unchanged record writes nothing.
+ *
+ * A rule grant whose rule is not among `rules` is dropped — the caller
+ * passes every active rule of the org, so a rule absent from them has been
+ * switched off or deleted.
+ */ export function evaluateRecordGrants(object, record, rules, atMs) {
+    const current = readRecordGrants(record);
+    const next = {};
+    for (const [key, grant] of Object.entries(current)){
+        if (grant.source === 'manual') next[key] = grant;
+    }
+    for (const rule of activeSharingRules(rules, object)){
+        if (!crmSharingRuleMatches(rule, object, record)) continue;
+        const key = ruleGrantKey(rule.id);
+        const before = current[key];
+        next[key] = {
+            source: 'rule',
+            ruleId: rule.id,
+            tokens: [
+                ...rule.targets
+            ],
+            access: rule.access,
+            atMs: before && sameList(before.tokens, rule.targets) && before.access === rule.access ? before.atMs : atMs
+        };
+    }
+    return next;
+}
+/** The hand shares after sharing with `targets`, by `by`. */ export function withManualShares(grants, targets, access, by, atMs) {
+    const next = _extends({}, grants);
+    for (const token of targets){
+        var _by_name;
+        const name = String((_by_name = by.name) != null ? _by_name : '').trim();
+        next[manualGrantKey(token)] = _extends({
+            source: 'manual',
+            tokens: [
+                token
+            ],
+            access,
+            byUid: by.uid
+        }, name ? {
+            byName: name
+        } : {}, {
+            atMs
+        });
+    }
+    return next;
+}
+/** The hand shares after unsharing `targets`. Rule grants are the rule's to take away. */ export function withoutManualShares(grants, targets) {
+    const drop = new Set(targets.filter(isScopeToken).map(manualGrantKey));
+    return Object.fromEntries(Object.entries(grants).filter(([key])=>!drop.has(key)));
+}
+/*==========================================
+ * WHAT A READER SEES.
+ *=========================================*/ /**
+ * Whether a caller holding `tokens` may write the record: `writeTo` on a
+ * shared record, else `visibleTo` — the Firestore rules' own predicate.
+ */ export function crmRecordWritableBy(record, tokens) {
+    const writeTo = record[CRM_WRITE_SCOPE_FIELD];
+    const scope = Array.isArray(writeTo) ? writeTo : record['visibleTo'];
+    if (!Array.isArray(scope) || !tokens.length) return false;
+    return scope.some((token)=>tokens.includes(token));
+}
+/**
+ * Why a site seeing this record sees it, when the answer is a share — or
+ * `null` when the site holds it (or cannot see it at all). `hostIds` are
+ * the viewing group's sites; at the organization level there is none.
+ */ export function crmShareChipFor(record, hostIds) {
+    var _ref, _ref1, _reaching_find;
+    if (!record || !hostIds.length) return null;
+    const held = recordHeldScope(record);
+    if (held.includes(ORG_SCOPE_TOKEN)) return null;
+    const viewing = new Set(hostIds.map(hostScopeToken));
+    if (held.some((token)=>viewing.has(token))) return null;
+    const grants = Object.values(readRecordGrants(record));
+    const reaching = grants.filter((grant)=>grant.tokens.some((token)=>token === ORG_SCOPE_TOKEN || viewing.has(token)));
+    if (!reaching.length) return null;
+    // A hand share names a person, so it leads; an edit grant outranks read.
+    const pick = (_ref = (_ref1 = (_reaching_find = reaching.find((grant)=>grant.source === 'manual' && grant.access === 'edit')) != null ? _reaching_find : reaching.find((grant)=>grant.source === 'manual')) != null ? _ref1 : reaching.find((grant)=>grant.access === 'edit')) != null ? _ref : reaching[0];
+    return _extends({
+        source: pick.source,
+        access: reaching.some((grant)=>grant.access === 'edit') ? 'edit' : 'read'
+    }, pick.byName ? {
+        byName: pick.byName
+    } : {}, pick.ruleId ? {
+        ruleId: pick.ruleId
+    } : {}, {
+        allSites: pick.tokens.includes(ORG_SCOPE_TOKEN)
+    });
+}
+/** The chip's words: "Shared by Dana", "Shared by rule Brand A leads". */ export function crmShareChipLabel(chip, rules = []) {
+    if (chip.source === 'manual') return chip.byName ? `Shared by ${chip.byName}` : 'Shared by hand';
+    const rule = rules.find((entry)=>entry.id === chip.ruleId);
+    return rule ? `Shared by rule ${rule.name}` : 'Shared by a rule';
+}
+/**
+ * Where a record is visible and why: the sites that hold it (its consent
+ * group or its creating site), then one line per hand share, then one per
+ * rule. The held line is never unsharable; a hand share is, in one click.
+ */ export function describeRecordSharing(record) {
+    if (!record) return [];
+    const held = recordHeldScope(record);
+    const lines = [
+        {
+            kind: 'held',
+            hostIds: hostIdsFromScope(held),
+            allSites: held.includes(ORG_SCOPE_TOKEN)
+        }
+    ];
+    const grants = Object.entries(readRecordGrants(record));
+    for (const [key, grant] of grants){
+        if (grant.source !== 'manual') continue;
+        lines.push(_extends({
+            kind: 'manual',
+            key,
+            token: grant.tokens[0],
+            access: grant.access
+        }, grant.byName ? {
+            byName: grant.byName
+        } : {}, {
+            atMs: grant.atMs
+        }));
+    }
+    for (const [key, grant] of grants){
+        if (grant.source !== 'rule' || !grant.ruleId) continue;
+        lines.push({
+            kind: 'rule',
+            key,
+            ruleId: grant.ruleId,
+            tokens: grant.tokens,
+            access: grant.access,
+            atMs: grant.atMs
+        });
+    }
+    return lines;
+}
+/** "All sites", a site's name, or "N sites". */ export function describeShareTargets(tokens, siteName) {
+    if (tokens.includes(ORG_SCOPE_TOKEN)) return 'All sites';
+    const ids = hostIdsFromScope(tokens);
+    if (ids.length === 1) return siteName(ids[0]);
+    if (ids.length <= 3) return ids.map(siteName).join(', ');
+    return `${ids.length} sites`;
+}
+/** A rule as one sentence of its "which records" half. */ export function describeSharingRuleScope(rule, siteName, labels = {}) {
+    var _criteria_leadSources, _criteria_tags, _criteria_campaignIds, _criteria_stages, _criteria_ownerUids;
+    const parts = [
+        CRM_SHARING_OBJECT_LABELS[rule.object].many
+    ];
+    if (rule.sourceHostIds.length) {
+        parts.push(`captured on ${rule.sourceHostIds.map(siteName).join(' or ')}`);
+    }
+    const { criteria } = rule;
+    if ((_criteria_leadSources = criteria.leadSources) == null ? void 0 : _criteria_leadSources.length) parts.push(`from ${criteria.leadSources.join(' or ')}`);
+    if ((_criteria_tags = criteria.tags) == null ? void 0 : _criteria_tags.length) parts.push(`tagged ${criteria.tags.join(' or ')}`);
+    if ((_criteria_campaignIds = criteria.campaignIds) == null ? void 0 : _criteria_campaignIds.length) {
+        parts.push(`in ${criteria.campaignIds.length === 1 ? 'a campaign' : `${criteria.campaignIds.length} campaigns`}`);
+    }
+    if ((_criteria_stages = criteria.stages) == null ? void 0 : _criteria_stages.length) {
+        parts.push(`at ${criteria.stages.map((id)=>{
+            var _ref;
+            return (_ref = labels.stage == null ? void 0 : labels.stage.call(labels, id)) != null ? _ref : id;
+        }).join(' or ')}`);
+    }
+    if ((_criteria_ownerUids = criteria.ownerUids) == null ? void 0 : _criteria_ownerUids.length) {
+        parts.push(`owned by ${criteria.ownerUids.map((uid)=>{
+            var _ref;
+            return (_ref = labels.owner == null ? void 0 : labels.owner.call(labels, uid)) != null ? _ref : uid;
+        }).join(' or ')}`);
+    }
+    return parts.join(', ');
+}
+/*==========================================
+ * THE ROUTE.
+ *=========================================*/ /** `POST /api/crm/sharing` — every sharing act, by `action`. */ export const CRM_SHARING_ROUTE = 'crm/sharing';
+export const crmSharingRouteUrl = ()=>`/api/${CRM_SHARING_ROUTE}`;
+/** Records one share or unshare may name. */ export const CRM_SHARING_IDS_MAX = 200;
+
+//# sourceMappingURL=crm-sharing.js.map