@aglyn/aglyn 1.0.0-beta.221 → 1.0.0-beta.222

package/src/lib/app-utils/picklists.d.ts

@@ -0,0 +1,187 @@
+/**
+ * @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 most values one list holds — a menu, not a table. */
+export declare const PICKLIST_VALUES_MAX = 200;
+/** The longest label a value carries. */
+export declare const PICKLIST_LABEL_MAX = 120;
+/** One value of a list. `id` never changes; `label` is what records store. */
+export interface PicklistValue {
+    id: string;
+    label: string;
+    active: boolean;
+    /**
+     * The group the value is listed under, by group id; `null` for none.
+     * Present only on a list whose spec has groups.
+     */
+    group?: string | null;
+    /**
+     * What the value MEANS to the platform, from the spec's `meanings`;
+     * `null` for an added value that names none. Present only on a list whose
+     * spec has meanings, and fixed by the spec for a standard value.
+     */
+    meaning?: string | null;
+}
+/** A list as stored and as every reader takes it. */
+export interface PicklistValueSet {
+    /** In the order every picker lists them. */
+    values: PicklistValue[];
+    /** The value a new record starts with, by id — `null` for none. */
+    defaultValueId: string | null;
+}
+/** One value a spec ships to every organization. */
+export interface PicklistStandardValue {
+    id: string;
+    label: string;
+    group?: string;
+    meaning?: string;
+}
+/** One heading values may be listed under. */
+export interface PicklistGroup {
+    id: string;
+    label: string;
+}
+/** What the engine needs to know of a picklist. */
+export interface PicklistSpec {
+    /**
+     * A restricted list refuses a write naming a value it does not hold; an
+     * unrestricted one stores it as typed.
+     */
+    restricted: boolean;
+    /** The values every organization has, in their starting order. */
+    standardValues: readonly PicklistStandardValue[];
+    /** The value a new record starts with while the organization has stored no list. */
+    defaultValueId?: string;
+    /** The headings values are listed under, in order; ungrouped values come last. */
+    groups?: readonly PicklistGroup[];
+    /**
+     * The platform's own vocabulary for what a value means, when it has one.
+     * Every value carries one of these or `null`, and a value deleted with a
+     * replacement moves its records only to a value of the SAME meaning.
+     */
+    meanings?: readonly string[];
+}
+/** A label as a list stores it: trimmed, single-spaced, capped. */
+export declare function normalizePicklistLabel(value: unknown): string;
+/** The key two labels are compared by: case and spacing do not make a new value. */
+export declare function picklistLabelKey(label: unknown): string;
+/**
+ * A new value's id: the label as a slug, suffixed until it is not one of
+ * `taken`. Derived rather than random so a list reads the same in every
+ * organization, and never reused, because a default names a value by it.
+ * A caller minting an ADDED value counts every standard id as taken, so an
+ * added value can never be mistaken for a standard one.
+ */
+export declare function mintPicklistValueId(label: string, taken: Iterable<string>): string;
+/** A list of active values from labels, in order, with no default. */
+export declare function picklistFromLabels(labels: readonly string[]): PicklistValueSet;
+/** The standard value an id names under `spec`, or `null`. */
+export declare function picklistStandardValue(spec: PicklistSpec, id: string | null | undefined): PicklistStandardValue | null;
+/** Whether `id` is one of the spec's standard values — computed, never stored. */
+export declare function isStandardPicklistValueId(spec: PicklistSpec, id: string | null | undefined): boolean;
+/**
+ * A stored document as a list, or `null` for one that holds none.
+ *
+ * Tolerant, because the document is client-written: a value with no label
+ * is dropped, a second value with the same label (in any case) or the same
+ * id is dropped, `active` is true unless it is `false`, and a default that
+ * names no value is no default. With a `spec`, each value's group and
+ * meaning are read against it as well.
+ */
+export declare function normalizePicklistValueSet(raw: unknown, spec?: PicklistSpec): PicklistValueSet | null;
+/**
+ * The effective list: `stored` (already normalized against `spec`) with
+ * every standard value it lacks — see the block header. `null` for an
+ * organization that stored nothing answers the standard values in order,
+ * with the spec's default.
+ */
+export declare function mergePicklistStandard(spec: PicklistSpec, stored: PicklistValueSet | null): PicklistValueSet;
+/** A stored document as every reader should take it under `spec`. */
+export declare function effectivePicklistValueSet(spec: PicklistSpec, raw: unknown): PicklistValueSet;
+/** The value a label names, in any case or spacing — `null` for none. */
+export declare function picklistValueByLabel(set: PicklistValueSet, label: unknown): PicklistValue | null;
+/** The values a picker offers. */
+export declare function picklistActiveValues(set: PicklistValueSet): PicklistValue[];
+/** The label a new record starts with — only while the default value is active. */
+export declare function picklistDefaultLabel(set: PicklistValueSet): string | null;
+/**
+ * The sentence a value outside a restricted list is refused with, naming
+ * what the list allows: `{field} must be one of: …`. A long list is cut at
+ * twenty names so the sentence stays one a person can read; `empty` is the
+ * sentence for a list with no active value at all.
+ */
+export declare function picklistRefusalSentence(set: PicklistValueSet, words: {
+    field: string;
+    empty: string;
+}): string;
+/** What a judged write stores, or why it is refused. */
+export type PicklistJudgement = {
+    ok: true;
+    value: string | null;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Whether a write may store `value` on a record, and the label it stores.
+ *
+ *  - Blank or `null` clears the field.
+ *  - An ACTIVE value, in any case or spacing, stores that value's label.
+ *  - The record's `current` value is kept even when it is inactive or no
+ *    longer listed: re-saving a record must never be refused for a value
+ *    somebody else deactivated.
+ *  - On an unrestricted list anything else is stored — as the list spells
+ *    it when the list holds it, else as typed.
+ *  - On a restricted list anything else is refused with `refusal()`.
+ */
+export declare function judgePicklistValue(set: PicklistValueSet, value: unknown, options: {
+    restricted: boolean;
+    current?: unknown;
+    refusal: () => string;
+}): PicklistJudgement;
+/** One option of a select over a list. */
+export interface PicklistOption {
+    label: string;
+    /** Listed but deactivated — shown with an "(inactive)" hint. */
+    inactive: boolean;
+    /** Not in the list at all — a value written before the list held it. */
+    unlisted: boolean;
+    /** The group it is listed under, when the list has groups; `null` for none. */
+    group?: string | null;
+}
+/**
+ * What a select offers for a record holding `current`: every active value
+ * in order, then the record's own value when the list would not otherwise
+ * show it, so the select keeps what the record holds until it is changed.
+ */
+export declare function picklistOptions(set: PicklistValueSet, current?: unknown): PicklistOption[];
+/** One heading of a grouped select and the options under it; `group` null is the ungrouped tail. */
+export interface PicklistOptionGroup {
+    group: PicklistGroup | null;
+    options: PicklistOption[];
+}
+/**
+ * Options under their headings: each group in the spec's order, then every
+ * option with no group (or an unknown one) last. A heading with no option
+ * is left out, and the list's own order holds within each.
+ */
+export declare function groupPicklistOptions(options: readonly PicklistOption[], groups: readonly PicklistGroup[]): PicklistOptionGroup[];
+/**
+ * Where a label sorts: its value's position in the list, unlisted values
+ * after every listed one, and a record with none last. The order the admin
+ * chose is the order a sort by the field reads in.
+ */
+export declare function picklistRank(set: PicklistValueSet, label: unknown): number;

package/src/lib/app-utils/picklists.js

@@ -0,0 +1,320 @@
+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.
+ */ /*==========================================
+ * PICKLISTS — a field whose choices an admin keeps.
+ *
+ * The engine under every standard picklist a plugin declares (AGL-3510).
+ * It knows nothing of the records that hold the values; a plugin names its
+ * picklists in a registry of its own, each one a {@link PicklistSpec}, and
+ * asks this module what the effective list is, whether a write may store a
+ * value, and what a select offers.
+ *
+ * ## Standard values are built in
+ *
+ * A spec ships STANDARD values that every organization has whether or not
+ * it ever stored a list. An admin may relabel, reorder, deactivate, regroup
+ * or make one the default — all of which is stored under the standard
+ * value's own id — but never delete it, and the organization ADDS its own
+ * values beside them. Whether a value is standard is computed from its id
+ * every time it is asked (see {@link isStandardPicklistValueId}); nothing a
+ * stored document says about it is believed.
+ *
+ * ## The effective list
+ *
+ * The stored values in their stored order, then every standard value the
+ * document does not hold, appended active in the spec's order. A stored
+ * value whose id is a standard id IS that standard value, overridden. A
+ * stored value that is not standard but carries a missing standard value's
+ * label is adopted as it — it takes the standard id — so two values never
+ * share a label. A missing standard value whose label a stored STANDARD
+ * value has taken (one standard renamed onto another's name) stays out until
+ * that rename is undone; labels are unique before anything else.
+ *
+ * ## Records store the LABEL
+ *
+ * Every reader compares labels by {@link picklistLabelKey} — case and
+ * spacing never make a new value — and a write stores the label as the list
+ * spells it. Ids key the list itself: the default, a reorder, a row.
+ *=========================================*/ /** The most values one list holds — a menu, not a table. */ export const PICKLIST_VALUES_MAX = 200;
+/** The longest label a value carries. */ export const PICKLIST_LABEL_MAX = 120;
+/** A label as a list stores it: trimmed, single-spaced, capped. */ export function normalizePicklistLabel(value) {
+    return String(value != null ? value : '').trim().replace(/\s+/g, ' ').slice(0, PICKLIST_LABEL_MAX);
+}
+/** The key two labels are compared by: case and spacing do not make a new value. */ export function picklistLabelKey(label) {
+    return normalizePicklistLabel(label).toLowerCase();
+}
+/**
+ * A new value's id: the label as a slug, suffixed until it is not one of
+ * `taken`. Derived rather than random so a list reads the same in every
+ * organization, and never reused, because a default names a value by it.
+ * A caller minting an ADDED value counts every standard id as taken, so an
+ * added value can never be mistaken for a standard one.
+ */ export function mintPicklistValueId(label, taken) {
+    const used = new Set(taken);
+    const base = normalizePicklistLabel(label).toLowerCase().normalize('NFKD').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'value';
+    let id = base;
+    for(let n = 2; used.has(id); n += 1)id = `${base}-${n}`;
+    return id;
+}
+/** A list of active values from labels, in order, with no default. */ export function picklistFromLabels(labels) {
+    const values = [];
+    const seen = new Set();
+    for (const raw of labels){
+        const label = normalizePicklistLabel(raw);
+        if (!label || seen.has(picklistLabelKey(label))) continue;
+        seen.add(picklistLabelKey(label));
+        values.push({
+            id: mintPicklistValueId(label, values.map((value)=>value.id)),
+            label,
+            active: true
+        });
+    }
+    return {
+        values: values.slice(0, PICKLIST_VALUES_MAX),
+        defaultValueId: null
+    };
+}
+/** The standard value an id names under `spec`, or `null`. */ export function picklistStandardValue(spec, id) {
+    var _spec_standardValues_find;
+    return (_spec_standardValues_find = spec.standardValues.find((value)=>value.id === id)) != null ? _spec_standardValues_find : null;
+}
+/** Whether `id` is one of the spec's standard values — computed, never stored. */ export function isStandardPicklistValueId(spec, id) {
+    return picklistStandardValue(spec, id) !== null;
+}
+/** A group id the spec knows, or `null`. */ function knownGroup(spec, value) {
+    var _spec_groups;
+    return typeof value === 'string' && ((_spec_groups = spec.groups) == null ? void 0 : _spec_groups.some((group)=>group.id === value)) ? value : null;
+}
+/** A meaning the spec knows, or `null`. */ function knownMeaning(spec, value) {
+    var _spec_meanings;
+    return typeof value === 'string' && ((_spec_meanings = spec.meanings) == null ? void 0 : _spec_meanings.includes(value)) ? value : null;
+}
+/**
+ * The spec-dependent fields of one value: its group and its meaning, each
+ * present only when the spec has them. A standard value's meaning is the
+ * spec's whatever was stored; its group is the stored one when the document
+ * names one (`null` included — an admin may ungroup it), else the spec's.
+ */ function specFields(spec, id, entry) {
+    var _spec_groups, _spec_meanings;
+    if (!spec) return {};
+    const standard = picklistStandardValue(spec, id);
+    const fields = {};
+    if ((_spec_groups = spec.groups) == null ? void 0 : _spec_groups.length) {
+        fields.group = 'group' in entry ? knownGroup(spec, entry['group']) : knownGroup(spec, standard == null ? void 0 : standard.group);
+    }
+    if ((_spec_meanings = spec.meanings) == null ? void 0 : _spec_meanings.length) {
+        fields.meaning = standard ? knownMeaning(spec, standard.meaning) : knownMeaning(spec, entry['meaning']);
+    }
+    return fields;
+}
+/**
+ * A stored document as a list, or `null` for one that holds none.
+ *
+ * Tolerant, because the document is client-written: a value with no label
+ * is dropped, a second value with the same label (in any case) or the same
+ * id is dropped, `active` is true unless it is `false`, and a default that
+ * names no value is no default. With a `spec`, each value's group and
+ * meaning are read against it as well.
+ */ export function normalizePicklistValueSet(raw, spec) {
+    var _stored_defaultValueId;
+    if (!raw || typeof raw !== 'object') return null;
+    const stored = raw;
+    if (!Array.isArray(stored['values'])) return null;
+    const values = [];
+    const labels = new Set();
+    const ids = new Set();
+    for (const entry of stored['values']){
+        var _value_id;
+        if (!entry || typeof entry !== 'object') continue;
+        const value = entry;
+        const label = normalizePicklistLabel(value['label']);
+        if (!label || labels.has(picklistLabelKey(label))) continue;
+        let id = String((_value_id = value['id']) != null ? _value_id : '').trim().slice(0, 64);
+        if (!id || id.includes('/') || ids.has(id)) {
+            var _ref;
+            id = mintPicklistValueId(label, [
+                ...ids,
+                ...(_ref = spec == null ? void 0 : spec.standardValues.map((entry)=>entry.id)) != null ? _ref : []
+            ]);
+        }
+        labels.add(picklistLabelKey(label));
+        ids.add(id);
+        values.push(_extends({
+            id,
+            label,
+            active: value['active'] !== false
+        }, specFields(spec, id, value)));
+        if (values.length >= PICKLIST_VALUES_MAX) break;
+    }
+    const defaultId = String((_stored_defaultValueId = stored['defaultValueId']) != null ? _stored_defaultValueId : '');
+    return {
+        values,
+        defaultValueId: ids.has(defaultId) ? defaultId : null
+    };
+}
+/**
+ * The effective list: `stored` (already normalized against `spec`) with
+ * every standard value it lacks — see the block header. `null` for an
+ * organization that stored nothing answers the standard values in order,
+ * with the spec's default.
+ */ export function mergePicklistStandard(spec, stored) {
+    var _spec_defaultValueId;
+    const values = stored ? stored.values.map((value)=>_extends({}, value)) : [];
+    let defaultValueId = stored ? stored.defaultValueId : (_spec_defaultValueId = spec.defaultValueId) != null ? _spec_defaultValueId : null;
+    for (const standard of spec.standardValues){
+        if (values.some((value)=>value.id === standard.id)) continue;
+        const key = picklistLabelKey(standard.label);
+        const holder = values.find((value)=>picklistLabelKey(value.label) === key);
+        if (holder) {
+            var _spec_meanings;
+            if (isStandardPicklistValueId(spec, holder.id)) continue;
+            if (defaultValueId === holder.id) defaultValueId = standard.id;
+            holder.id = standard.id;
+            if ((_spec_meanings = spec.meanings) == null ? void 0 : _spec_meanings.length) holder.meaning = knownMeaning(spec, standard.meaning);
+            continue;
+        }
+        values.push(_extends({
+            id: standard.id,
+            label: normalizePicklistLabel(standard.label),
+            active: true
+        }, specFields(spec, standard.id, {})));
+    }
+    return {
+        values,
+        defaultValueId: values.some((value)=>value.id === defaultValueId) ? defaultValueId : null
+    };
+}
+/** A stored document as every reader should take it under `spec`. */ export function effectivePicklistValueSet(spec, raw) {
+    return mergePicklistStandard(spec, normalizePicklistValueSet(raw, spec));
+}
+/** The value a label names, in any case or spacing — `null` for none. */ export function picklistValueByLabel(set, label) {
+    var _set_values_find;
+    const key = picklistLabelKey(label);
+    if (!key) return null;
+    return (_set_values_find = set.values.find((value)=>picklistLabelKey(value.label) === key)) != null ? _set_values_find : null;
+}
+/** The values a picker offers. */ export function picklistActiveValues(set) {
+    return set.values.filter((value)=>value.active);
+}
+/** The label a new record starts with — only while the default value is active. */ export function picklistDefaultLabel(set) {
+    const value = set.values.find((entry)=>entry.id === set.defaultValueId);
+    return (value == null ? void 0 : value.active) ? value.label : null;
+}
+/**
+ * The sentence a value outside a restricted list is refused with, naming
+ * what the list allows: `{field} must be one of: …`. A long list is cut at
+ * twenty names so the sentence stays one a person can read; `empty` is the
+ * sentence for a list with no active value at all.
+ */ export function picklistRefusalSentence(set, words) {
+    const active = picklistActiveValues(set).map((value)=>value.label);
+    if (!active.length) return words.empty;
+    const shown = active.slice(0, 20).join(', ');
+    const more = active.length > 20 ? `, and ${active.length - 20} more` : '';
+    return `${words.field} must be one of: ${shown}${more}.`;
+}
+/**
+ * Whether a write may store `value` on a record, and the label it stores.
+ *
+ *  - Blank or `null` clears the field.
+ *  - An ACTIVE value, in any case or spacing, stores that value's label.
+ *  - The record's `current` value is kept even when it is inactive or no
+ *    longer listed: re-saving a record must never be refused for a value
+ *    somebody else deactivated.
+ *  - On an unrestricted list anything else is stored — as the list spells
+ *    it when the list holds it, else as typed.
+ *  - On a restricted list anything else is refused with `refusal()`.
+ */ export function judgePicklistValue(set, value, options) {
+    var _ref;
+    const label = normalizePicklistLabel(value);
+    if (!label) return {
+        ok: true,
+        value: null
+    };
+    const held = normalizePicklistLabel(options.current);
+    if (held && picklistLabelKey(held) === picklistLabelKey(label)) return {
+        ok: true,
+        value: held
+    };
+    const match = picklistValueByLabel(set, label);
+    if (match == null ? void 0 : match.active) return {
+        ok: true,
+        value: match.label
+    };
+    if (!options.restricted) return {
+        ok: true,
+        value: (_ref = match == null ? void 0 : match.label) != null ? _ref : label
+    };
+    return {
+        ok: false,
+        error: options.refusal()
+    };
+}
+/**
+ * What a select offers for a record holding `current`: every active value
+ * in order, then the record's own value when the list would not otherwise
+ * show it, so the select keeps what the record holds until it is changed.
+ */ export function picklistOptions(set, current) {
+    const option = (value, inactive)=>_extends({
+            label: value.label,
+            inactive,
+            unlisted: false
+        }, value.group !== undefined ? {
+            group: value.group
+        } : {});
+    const options = picklistActiveValues(set).map((value)=>option(value, false));
+    const held = normalizePicklistLabel(current);
+    if (held && !options.some((entry)=>picklistLabelKey(entry.label) === picklistLabelKey(held))) {
+        const listed = picklistValueByLabel(set, held);
+        // The record's own spelling, so the select finds the option it holds.
+        options.push(listed ? _extends({}, option(listed, true), {
+            label: held
+        }) : {
+            label: held,
+            inactive: false,
+            unlisted: true
+        });
+    }
+    return options;
+}
+/**
+ * Options under their headings: each group in the spec's order, then every
+ * option with no group (or an unknown one) last. A heading with no option
+ * is left out, and the list's own order holds within each.
+ */ export function groupPicklistOptions(options, groups) {
+    const known = new Set(groups.map((group)=>group.id));
+    const sections = groups.map((group)=>({
+            group,
+            options: options.filter((option)=>option.group === group.id)
+        }));
+    sections.push({
+        group: null,
+        options: options.filter((option)=>!option.group || !known.has(option.group))
+    });
+    return sections.filter((section)=>section.options.length > 0);
+}
+/**
+ * Where a label sorts: its value's position in the list, unlisted values
+ * after every listed one, and a record with none last. The order the admin
+ * chose is the order a sort by the field reads in.
+ */ export function picklistRank(set, label) {
+    const key = picklistLabelKey(label);
+    if (!key) return Number.MAX_SAFE_INTEGER;
+    const at = set.values.findIndex((value)=>picklistLabelKey(value.label) === key);
+    return at < 0 ? PICKLIST_VALUES_MAX : at;
+}
+
+//# sourceMappingURL=picklists.js.map

package/src/lib/app-utils/picklists.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/picklists.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*==========================================\n * PICKLISTS — a field whose choices an admin keeps.\n *\n * The engine under every standard picklist a plugin declares (AGL-3510).\n * It knows nothing of the records that hold the values; a plugin names its\n * picklists in a registry of its own, each one a {@link PicklistSpec}, and\n * asks this module what the effective list is, whether a write may store a\n * value, and what a select offers.\n *\n * ## Standard values are built in\n *\n * A spec ships STANDARD values that every organization has whether or not\n * it ever stored a list. An admin may relabel, reorder, deactivate, regroup\n * or make one the default — all of which is stored under the standard\n * value's own id — but never delete it, and the organization ADDS its own\n * values beside them. Whether a value is standard is computed from its id\n * every time it is asked (see {@link isStandardPicklistValueId}); nothing a\n * stored document says about it is believed.\n *\n * ## The effective list\n *\n * The stored values in their stored order, then every standard value the\n * document does not hold, appended active in the spec's order. A stored\n * value whose id is a standard id IS that standard value, overridden. A\n * stored value that is not standard but carries a missing standard value's\n * label is adopted as it — it takes the standard id — so two values never\n * share a label. A missing standard value whose label a stored STANDARD\n * value has taken (one standard renamed onto another's name) stays out until\n * that rename is undone; labels are unique before anything else.\n *\n * ## Records store the LABEL\n *\n * Every reader compares labels by {@link picklistLabelKey} — case and\n * spacing never make a new value — and a write stores the label as the list\n * spells it. Ids key the list itself: the default, a reorder, a row.\n *=========================================*/\n\n/** The most values one list holds — a menu, not a table. */\nexport const PICKLIST_VALUES_MAX = 200\n\n/** The longest label a value carries. */\nexport const PICKLIST_LABEL_MAX = 120\n\n/** One value of a list. `id` never changes; `label` is what records store. */\nexport interface PicklistValue {\n  id: string\n  label: string\n  active: boolean\n  /**\n   * The group the value is listed under, by group id; `null` for none.\n   * Present only on a list whose spec has groups.\n   */\n  group?: string | null\n  /**\n   * What the value MEANS to the platform, from the spec's `meanings`;\n   * `null` for an added value that names none. Present only on a list whose\n   * spec has meanings, and fixed by the spec for a standard value.\n   */\n  meaning?: string | null\n}\n\n/** A list as stored and as every reader takes it. */\nexport interface PicklistValueSet {\n  /** In the order every picker lists them. */\n  values: PicklistValue[]\n  /** The value a new record starts with, by id — `null` for none. */\n  defaultValueId: string | null\n}\n\n/** One value a spec ships to every organization. */\nexport interface PicklistStandardValue {\n  id: string\n  label: string\n  group?: string\n  meaning?: string\n}\n\n/** One heading values may be listed under. */\nexport interface PicklistGroup {\n  id: string\n  label: string\n}\n\n/** What the engine needs to know of a picklist. */\nexport interface PicklistSpec {\n  /**\n   * A restricted list refuses a write naming a value it does not hold; an\n   * unrestricted one stores it as typed.\n   */\n  restricted: boolean\n  /** The values every organization has, in their starting order. */\n  standardValues: readonly PicklistStandardValue[]\n  /** The value a new record starts with while the organization has stored no list. */\n  defaultValueId?: string\n  /** The headings values are listed under, in order; ungrouped values come last. */\n  groups?: readonly PicklistGroup[]\n  /**\n   * The platform's own vocabulary for what a value means, when it has one.\n   * Every value carries one of these or `null`, and a value deleted with a\n   * replacement moves its records only to a value of the SAME meaning.\n   */\n  meanings?: readonly string[]\n}\n\n/** A label as a list stores it: trimmed, single-spaced, capped. */\nexport function normalizePicklistLabel(value: unknown): string {\n  return String(value ?? '')\n    .trim()\n    .replace(/\\s+/g, ' ')\n    .slice(0, PICKLIST_LABEL_MAX)\n}\n\n/** The key two labels are compared by: case and spacing do not make a new value. */\nexport function picklistLabelKey(label: unknown): string {\n  return normalizePicklistLabel(label).toLowerCase()\n}\n\n/**\n * A new value's id: the label as a slug, suffixed until it is not one of\n * `taken`. Derived rather than random so a list reads the same in every\n * organization, and never reused, because a default names a value by it.\n * A caller minting an ADDED value counts every standard id as taken, so an\n * added value can never be mistaken for a standard one.\n */\nexport function mintPicklistValueId(label: string, taken: Iterable<string>): string {\n  const used = new Set(taken)\n  const base =\n    normalizePicklistLabel(label)\n      .toLowerCase()\n      .normalize('NFKD')\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/^-+|-+$/g, '')\n      .slice(0, 40) || 'value'\n  let id = base\n  for (let n = 2; used.has(id); n += 1) id = `${base}-${n}`\n  return id\n}\n\n/** A list of active values from labels, in order, with no default. */\nexport function picklistFromLabels(labels: readonly string[]): PicklistValueSet {\n  const values: PicklistValue[] = []\n  const seen = new Set<string>()\n  for (const raw of labels) {\n    const label = normalizePicklistLabel(raw)\n    if (!label || seen.has(picklistLabelKey(label))) continue\n    seen.add(picklistLabelKey(label))\n    values.push({ id: mintPicklistValueId(label, values.map((value) => value.id)), label, active: true })\n  }\n  return { values: values.slice(0, PICKLIST_VALUES_MAX), defaultValueId: null }\n}\n\n/** The standard value an id names under `spec`, or `null`. */\nexport function picklistStandardValue(\n  spec: PicklistSpec,\n  id: string | null | undefined,\n): PicklistStandardValue | null {\n  return spec.standardValues.find((value) => value.id === id) ?? null\n}\n\n/** Whether `id` is one of the spec's standard values — computed, never stored. */\nexport function isStandardPicklistValueId(spec: PicklistSpec, id: string | null | undefined): boolean {\n  return picklistStandardValue(spec, id) !== null\n}\n\n/** A group id the spec knows, or `null`. */\nfunction knownGroup(spec: PicklistSpec, value: unknown): string | null {\n  return typeof value === 'string' && spec.groups?.some((group) => group.id === value)\n    ? value\n    : null\n}\n\n/** A meaning the spec knows, or `null`. */\nfunction knownMeaning(spec: PicklistSpec, value: unknown): string | null {\n  return typeof value === 'string' && spec.meanings?.includes(value) ? value : null\n}\n\n/**\n * The spec-dependent fields of one value: its group and its meaning, each\n * present only when the spec has them. A standard value's meaning is the\n * spec's whatever was stored; its group is the stored one when the document\n * names one (`null` included — an admin may ungroup it), else the spec's.\n */\nfunction specFields(\n  spec: PicklistSpec | undefined,\n  id: string,\n  entry: Record<string, unknown>,\n): Pick<PicklistValue, 'group' | 'meaning'> {\n  if (!spec) return {}\n  const standard = picklistStandardValue(spec, id)\n  const fields: Pick<PicklistValue, 'group' | 'meaning'> = {}\n  if (spec.groups?.length) {\n    fields.group =\n      'group' in entry ? knownGroup(spec, entry['group']) : knownGroup(spec, standard?.group)\n  }\n  if (spec.meanings?.length) {\n    fields.meaning = standard ? knownMeaning(spec, standard.meaning) : knownMeaning(spec, entry['meaning'])\n  }\n  return fields\n}\n\n/**\n * A stored document as a list, or `null` for one that holds none.\n *\n * Tolerant, because the document is client-written: a value with no label\n * is dropped, a second value with the same label (in any case) or the same\n * id is dropped, `active` is true unless it is `false`, and a default that\n * names no value is no default. With a `spec`, each value's group and\n * meaning are read against it as well.\n */\nexport function normalizePicklistValueSet(\n  raw: unknown,\n  spec?: PicklistSpec,\n): PicklistValueSet | null {\n  if (!raw || typeof raw !== 'object') return null\n  const stored = raw as Record<string, unknown>\n  if (!Array.isArray(stored['values'])) return null\n  const values: PicklistValue[] = []\n  const labels = new Set<string>()\n  const ids = new Set<string>()\n  for (const entry of stored['values']) {\n    if (!entry || typeof entry !== 'object') continue\n    const value = entry as Record<string, unknown>\n    const label = normalizePicklistLabel(value['label'])\n    if (!label || labels.has(picklistLabelKey(label))) continue\n    let id = String(value['id'] ?? '').trim().slice(0, 64)\n    if (!id || id.includes('/') || ids.has(id)) {\n      id = mintPicklistValueId(label, [...ids, ...(spec?.standardValues.map((entry) => entry.id) ?? [])])\n    }\n    labels.add(picklistLabelKey(label))\n    ids.add(id)\n    values.push({ id, label, active: value['active'] !== false, ...specFields(spec, id, value) })\n    if (values.length >= PICKLIST_VALUES_MAX) break\n  }\n  const defaultId = String(stored['defaultValueId'] ?? '')\n  return {\n    values,\n    defaultValueId: ids.has(defaultId) ? defaultId : null,\n  }\n}\n\n/**\n * The effective list: `stored` (already normalized against `spec`) with\n * every standard value it lacks — see the block header. `null` for an\n * organization that stored nothing answers the standard values in order,\n * with the spec's default.\n */\nexport function mergePicklistStandard(\n  spec: PicklistSpec,\n  stored: PicklistValueSet | null,\n): PicklistValueSet {\n  const values: PicklistValue[] = stored ? stored.values.map((value) => ({ ...value })) : []\n  let defaultValueId = stored ? stored.defaultValueId : (spec.defaultValueId ?? null)\n  for (const standard of spec.standardValues) {\n    if (values.some((value) => value.id === standard.id)) continue\n    const key = picklistLabelKey(standard.label)\n    const holder = values.find((value) => picklistLabelKey(value.label) === key)\n    if (holder) {\n      if (isStandardPicklistValueId(spec, holder.id)) continue\n      if (defaultValueId === holder.id) defaultValueId = standard.id\n      holder.id = standard.id\n      if (spec.meanings?.length) holder.meaning = knownMeaning(spec, standard.meaning)\n      continue\n    }\n    values.push({\n      id: standard.id,\n      label: normalizePicklistLabel(standard.label),\n      active: true,\n      ...specFields(spec, standard.id, {}),\n    })\n  }\n  return {\n    values,\n    defaultValueId: values.some((value) => value.id === defaultValueId) ? defaultValueId : null,\n  }\n}\n\n/** A stored document as every reader should take it under `spec`. */\nexport function effectivePicklistValueSet(spec: PicklistSpec, raw: unknown): PicklistValueSet {\n  return mergePicklistStandard(spec, normalizePicklistValueSet(raw, spec))\n}\n\n/** The value a label names, in any case or spacing — `null` for none. */\nexport function picklistValueByLabel(set: PicklistValueSet, label: unknown): PicklistValue | null {\n  const key = picklistLabelKey(label)\n  if (!key) return null\n  return set.values.find((value) => picklistLabelKey(value.label) === key) ?? null\n}\n\n/** The values a picker offers. */\nexport function picklistActiveValues(set: PicklistValueSet): PicklistValue[] {\n  return set.values.filter((value) => value.active)\n}\n\n/** The label a new record starts with — only while the default value is active. */\nexport function picklistDefaultLabel(set: PicklistValueSet): string | null {\n  const value = set.values.find((entry) => entry.id === set.defaultValueId)\n  return value?.active ? value.label : null\n}\n\n/**\n * The sentence a value outside a restricted list is refused with, naming\n * what the list allows: `{field} must be one of: …`. A long list is cut at\n * twenty names so the sentence stays one a person can read; `empty` is the\n * sentence for a list with no active value at all.\n */\nexport function picklistRefusalSentence(\n  set: PicklistValueSet,\n  words: { field: string; empty: string },\n): string {\n  const active = picklistActiveValues(set).map((value) => value.label)\n  if (!active.length) return words.empty\n  const shown = active.slice(0, 20).join(', ')\n  const more = active.length > 20 ? `, and ${active.length - 20} more` : ''\n  return `${words.field} must be one of: ${shown}${more}.`\n}\n\n/** What a judged write stores, or why it is refused. */\nexport type PicklistJudgement = { ok: true; value: string | null } | { ok: false; error: string }\n\n/**\n * Whether a write may store `value` on a record, and the label it stores.\n *\n *  - Blank or `null` clears the field.\n *  - An ACTIVE value, in any case or spacing, stores that value's label.\n *  - The record's `current` value is kept even when it is inactive or no\n *    longer listed: re-saving a record must never be refused for a value\n *    somebody else deactivated.\n *  - On an unrestricted list anything else is stored — as the list spells\n *    it when the list holds it, else as typed.\n *  - On a restricted list anything else is refused with `refusal()`.\n */\nexport function judgePicklistValue(\n  set: PicklistValueSet,\n  value: unknown,\n  options: { restricted: boolean; current?: unknown; refusal: () => string },\n): PicklistJudgement {\n  const label = normalizePicklistLabel(value)\n  if (!label) return { ok: true, value: null }\n  const held = normalizePicklistLabel(options.current)\n  if (held && picklistLabelKey(held) === picklistLabelKey(label)) return { ok: true, value: held }\n  const match = picklistValueByLabel(set, label)\n  if (match?.active) return { ok: true, value: match.label }\n  if (!options.restricted) return { ok: true, value: match?.label ?? label }\n  return { ok: false, error: options.refusal() }\n}\n\n/** One option of a select over a list. */\nexport interface PicklistOption {\n  label: string\n  /** Listed but deactivated — shown with an \"(inactive)\" hint. */\n  inactive: boolean\n  /** Not in the list at all — a value written before the list held it. */\n  unlisted: boolean\n  /** The group it is listed under, when the list has groups; `null` for none. */\n  group?: string | null\n}\n\n/**\n * What a select offers for a record holding `current`: every active value\n * in order, then the record's own value when the list would not otherwise\n * show it, so the select keeps what the record holds until it is changed.\n */\nexport function picklistOptions(set: PicklistValueSet, current?: unknown): PicklistOption[] {\n  const option = (value: PicklistValue, inactive: boolean): PicklistOption => ({\n    label: value.label,\n    inactive,\n    unlisted: false,\n    ...(value.group !== undefined ? { group: value.group } : {}),\n  })\n  const options = picklistActiveValues(set).map((value) => option(value, false))\n  const held = normalizePicklistLabel(current)\n  if (held && !options.some((entry) => picklistLabelKey(entry.label) === picklistLabelKey(held))) {\n    const listed = picklistValueByLabel(set, held)\n    // The record's own spelling, so the select finds the option it holds.\n    options.push(\n      listed\n        ? { ...option(listed, true), label: held }\n        : { label: held, inactive: false, unlisted: true },\n    )\n  }\n  return options\n}\n\n/** One heading of a grouped select and the options under it; `group` null is the ungrouped tail. */\nexport interface PicklistOptionGroup {\n  group: PicklistGroup | null\n  options: PicklistOption[]\n}\n\n/**\n * Options under their headings: each group in the spec's order, then every\n * option with no group (or an unknown one) last. A heading with no option\n * is left out, and the list's own order holds within each.\n */\nexport function groupPicklistOptions(\n  options: readonly PicklistOption[],\n  groups: readonly PicklistGroup[],\n): PicklistOptionGroup[] {\n  const known = new Set(groups.map((group) => group.id))\n  const sections: PicklistOptionGroup[] = groups.map((group) => ({\n    group,\n    options: options.filter((option) => option.group === group.id),\n  }))\n  sections.push({\n    group: null,\n    options: options.filter((option) => !option.group || !known.has(option.group)),\n  })\n  return sections.filter((section) => section.options.length > 0)\n}\n\n/**\n * Where a label sorts: its value's position in the list, unlisted values\n * after every listed one, and a record with none last. The order the admin\n * chose is the order a sort by the field reads in.\n */\nexport function picklistRank(set: PicklistValueSet, label: unknown): number {\n  const key = picklistLabelKey(label)\n  if (!key) return Number.MAX_SAFE_INTEGER\n  const at = set.values.findIndex((value) => picklistLabelKey(value.label) === key)\n  return at < 0 ? PICKLIST_VALUES_MAX : at\n}\n"],"names":["PICKLIST_VALUES_MAX","PICKLIST_LABEL_MAX","normalizePicklistLabel","value","String","trim","replace","slice","picklistLabelKey","label","toLowerCase","mintPicklistValueId","taken","used","Set","base","normalize","id","n","has","picklistFromLabels","labels","values","seen","raw","add","push","map","active","defaultValueId","picklistStandardValue","spec","standardValues","find","isStandardPicklistValueId","knownGroup","groups","some","group","knownMeaning","meanings","includes","specFields","entry","standard","fields","length","meaning","normalizePicklistValueSet","stored","Array","isArray","ids","defaultId","mergePicklistStandard","key","holder","effectivePicklistValueSet","picklistValueByLabel","set","picklistActiveValues","filter","picklistDefaultLabel","picklistRefusalSentence","words","empty","shown","join","more","field","judgePicklistValue","options","ok","held","current","match","restricted","error","refusal","picklistOptions","option","inactive","unlisted","undefined","listed","groupPicklistOptions","known","sections","section","picklistRank","Number","MAX_SAFE_INTEGER","at","findIndex"],"mappings":"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"}