@aglyn/plugins-data 1.0.0-beta.143

package/src/lib/components/dataset-schema-dialog.component.js

@@ -0,0 +1,979 @@
+/**
+ * @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.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { DATASET_FIELD_TYPE_LABELS, DATASET_FIELD_TYPES, defaultDatasetFieldId, getCustomFieldType, listCustomFieldTypes, validateDatasetFieldId, describeScope, effectiveDatasetModel, HOST_ACCESS_ROLES, hostScopeToken, narrowsScope, scopeCovers, ORG_SCOPE_TOKEN, scopeToStore, storedScope, visibleToHost } from "@aglyn/aglyn";
+import { useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Button, Checkbox, Alert, Chip, Dialog, DialogActions, DialogContent, DialogTitle, FormControlLabel, IconButton, MenuItem, Select, Stack, TextField, Typography } from "@mui/material";
+import { collection, doc, limit, query, updateDoc, where } from "firebase/firestore";
+import { useCallback, useEffect, useState } from "react";
+import { useFirestore, useFirestoreCollection, useOrgDataScope, useScopeTokens, useUser, writeGuardedBySeed } from "@aglyn/tenant-feature-instance";
+/** Types surfaced in the picker; the rest exist for compat, not authoring. */ const AUTHORABLE_TYPES = [
+    'text',
+    'bool',
+    'int32',
+    'float',
+    'timestamp',
+    'coordinates',
+    'sorted',
+    'reference'
+];
+/**
+ * Model builder (AGL-178): edits the AGL-177 typed model on a dataset —
+ * singular/plural display names (dod.ts Schema.Name), add/edit/remove/
+ * reorder fields, per-field type/required/default/description/validation.
+ * Schema-change policies (documented per the issue): type changes never
+ * rewrite documents — non-conforming values surface in the editor when it
+ * validates (AGL-179); removed fields leave orphaned values that strip
+ * lazily on next document save; fieldIds are stable keys — only display
+ * names rename.
+ */ export function DatasetSchemaDialog(props) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _find, _ref8, _ref9, _ref10, _ref11;
+    var _editorDefinition_reference, _editorDefinition_reference1, _editorDefinition_reference2, _editorDefinition_reference3, _editorDefinition_validation;
+    const { hostId, dataset, datasets, recordCount, seedFromCache, seedUnreadable, onClose } = props;
+    // Org-shared data root (AGL-237/239). Null until the async org lookup
+    // settles (AGL-1061), and for a host with no owning org. Saving is held
+    // on it rather than redirected: the host path this used to fall back to
+    // is now denied by the rules outright (AGL-1050), so a save there would
+    // fail loudly instead of quietly — but it should not be attempted at all.
+    const { scope: dataScope, orgId } = useOrgDataScope({
+        hostId,
+        orgId: props.orgId
+    });
+    const firestore = useFirestore();
+    const { enqueueSnackbar } = useSnackbar();
+    const { confirm } = useConfirmationContext();
+    // Sharing scope (AGL-1044) — org datasets only; the legacy host path is
+    // site-private by construction.
+    // `orgWide` reads TRUE while the member doc loads (AGL-1047), which would
+    // offer a scoped collaborator the scope Select for a beat before replacing
+    // it with the read-only summary — and offering a control the AGL-1041
+    // rules will reject is the thing the branch below exists to avoid. Hold
+    // the whole block until `loaded` rather than flash the wrong one.
+    const { orgWide: viewerOrgWide, loaded: scopeLoaded } = useScopeTokens(orgId != null ? orgId : undefined);
+    // Sites in this org, for naming what a narrowing would cost. Queried
+    // here rather than via the console's useOrgHosts — this component lives
+    // in a lib and cannot import from an app — so it must repeat that hook's
+    // membership filter, which is the part this was missing (AGL-1145).
+    //
+    // `/hosts/{hostId}` is gated per document on `memberRoles.{uid}`, and
+    // Firestore evaluates a LIST against the QUERY rather than its results: it
+    // refuses to run one that COULD return a denied document, whatever today's
+    // data happens to hold. So filtering on `orgId` alone was not a partial
+    // result, it was a flat denial for every non-staff caller — including one
+    // who is a member of every site in the org. Proved in the emulator
+    // (cloud/hosts-list-constraint.spec.mjs); the reason nobody hit it is that
+    // staff match the rule's other branch, and staff are who tested it.
+    const { data: user } = useUser();
+    const uid = user == null ? void 0 : user.uid;
+    const { data: orgHostDocs } = useFirestoreCollection(// Hold rather than substitute a placeholder while the uid resolves. The
+    // old `orgId ?? '-none-'` fired a real query on every mount before the
+    // scope was known; a sentinel is still a question asked of the server,
+    // and here it is one that gets denied.
+    ()=>uid && orgId ? query(collection(firestore, 'hosts'), where(`memberRoles.${uid}`, 'in', HOST_ACCESS_ROLES), where('orgId', '==', orgId), limit(200)) : null, [
+        firestore,
+        orgId,
+        uid
+    ], {
+        idField: '$id'
+    });
+    const orgHostList = orgHostDocs != null ? orgHostDocs : [];
+    const [visibleTo, setVisibleTo] = useState([]);
+    /**
+   * The dataset stores NO scope (AGL-1484) — as opposed to storing `['org']`.
+   *
+   * The dialog used to render the two identically, which for a dataset is a
+   * worse lie than it was for a media file: `orgs/{orgId}/datasets` is read
+   * with `array-contains-any` in `resolve-dataset.ts` and in the console's
+   * own `organizations.ts`, so an unstamped dataset is matched by no reader
+   * in the product. It renders on no site and is missing from the reference
+   * cards even for an org-wide member — while this control said "All sites".
+   */ const [scopeUnset, setScopeUnset] = useState(false);
+    const [model, setModel] = useState({
+        fields: {},
+        order: []
+    });
+    const [names, setNames] = useState({
+        singular: '',
+        plural: ''
+    });
+    useEffect(()=>{
+        var _ref, _ref1, _ref2;
+        var _dataset_names, _dataset_names1;
+        if (!dataset) return;
+        // The fourth copy of the AGL-1466 substitution (AGL-1484), and the seed
+        // half of it. Persisting the default on open was the other option and
+        // AGL-1466 ruled it out: opening a dialog would write, the AGL-1042
+        // rules refuse that write from anyone who is not org-wide, and it
+        // repairs only what somebody happens to look at — a repair mechanism
+        // wearing a UI. `previousScope` in `handleSave` reads the SAME helper;
+        // see the note there for why the pair is the safety property.
+        const storedDatasetScope = storedScope(dataset.visibleTo);
+        setVisibleTo(storedDatasetScope != null ? storedDatasetScope : []);
+        setScopeUnset(!storedDatasetScope);
+        const effective = effectiveDatasetModel(dataset);
+        setModel({
+            fields: JSON.parse(JSON.stringify(effective.fields)),
+            order: [
+                ...effective.order
+            ]
+        });
+        setNames({
+            singular: (_ref = (_dataset_names = dataset.names) == null ? void 0 : _dataset_names.singular) != null ? _ref : '',
+            plural: (_ref1 = (_ref2 = (_dataset_names1 = dataset.names) == null ? void 0 : _dataset_names1.plural) != null ? _ref2 : dataset.displayName) != null ? _ref1 : ''
+        });
+    }, [
+        dataset
+    ]);
+    // Per-field editor (null fieldId = new field). `idDraft`/`idTouched` back
+    // the editable Reference ID (AGL-578): for a new field the draft follows
+    // the display name until the user edits it; existing fields keep the id
+    // frozen (idTouched=true, input disabled).
+    const [fieldEditor, setFieldEditor] = useState(null);
+    const openFieldEditor = useCallback((fieldId)=>()=>{
+            var _ref;
+            var _definition_validation;
+            const definition = fieldId ? JSON.parse(JSON.stringify(model.fields[fieldId])) : {
+                name: '',
+                type: 'text'
+            };
+            setFieldEditor({
+                fieldId,
+                definition,
+                optionsText: ((_ref = (_definition_validation = definition.validation) == null ? void 0 : _definition_validation.options) != null ? _ref : []).join(', '),
+                idDraft: fieldId != null ? fieldId : '',
+                idTouched: fieldId != null
+            });
+        }, [
+        model
+    ]);
+    const handleFieldSave = useCallback(async ()=>{
+        var _definition_validation;
+        var _definition_description;
+        if (!fieldEditor) return;
+        const definition = _extends({}, fieldEditor.definition);
+        if (!definition.name.trim()) return;
+        definition.name = definition.name.trim();
+        // Descriptions (AGL-560) surface as hints wherever the field appears;
+        // blank ones are dropped so the model doesn't accrete empty strings.
+        const description = (_definition_description = definition.description) == null ? void 0 : _definition_description.trim();
+        if (description) definition.description = description;
+        else delete definition.description;
+        const options = fieldEditor.optionsText.split(',').map((option)=>option.trim()).filter(Boolean);
+        definition.validation = _extends({}, (_definition_validation = definition.validation) != null ? _definition_validation : {}, options.length ? {
+            options
+        } : {});
+        if (!options.length) delete definition.validation.options;
+        if (!Object.keys(definition.validation).length) delete definition.validation;
+        let fieldId = fieldEditor.fieldId;
+        if (!fieldId) {
+            // New field: the reference id comes from the (editable) draft, which
+            // defaulted from the display name. Validate before it becomes a key.
+            const id = fieldEditor.idDraft.trim();
+            const idError = validateDatasetFieldId(id, new Set(model.order.map((existing)=>existing.toLowerCase())));
+            if (idError) {
+                return void enqueueSnackbar(idError, {
+                    variant: 'warning',
+                    persist: false
+                });
+            }
+            fieldId = id;
+        } else if (recordCount > 0 && model.fields[fieldId] && model.fields[fieldId].type !== definition.type) {
+            // Documented policy: changing a type never rewrites documents;
+            // existing values that no longer conform get flagged when edited.
+            const confirmed = await confirm({
+                title: 'Change field type?',
+                description: `${recordCount} document${recordCount === 1 ? '' : 's'} exist. ` + 'Stored values are not rewritten — ones that no longer match ' + `"${DATASET_FIELD_TYPE_LABELS[definition.type]}" will be flagged ` + 'when documents are next edited.',
+                confirmationText: 'Change type'
+            }).then(()=>true).catch(()=>false);
+            if (!confirmed) return;
+        }
+        setModel((prev)=>({
+                fields: _extends({}, prev.fields, {
+                    [fieldId]: definition
+                }),
+                order: prev.order.includes(fieldId) ? prev.order : [
+                    ...prev.order,
+                    fieldId
+                ]
+            }));
+        setFieldEditor(null);
+    }, [
+        fieldEditor,
+        model,
+        recordCount,
+        confirm,
+        enqueueSnackbar
+    ]);
+    const handleFieldRemove = useCallback((fieldId)=>async ()=>{
+            var _ref;
+            var _model_fields_fieldId;
+            const confirmed = await confirm({
+                title: `Remove field "${(_ref = (_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.name) != null ? _ref : fieldId}"?`,
+                description: 'Existing documents keep their stored value until they are next ' + 'saved (it is stripped then). Bindings using this field stop ' + 'resolving.',
+                confirmationText: 'Remove',
+                confirmationButtonProps: {
+                    color: 'error'
+                }
+            }).then(()=>true).catch(()=>false);
+            if (!confirmed) return;
+            setModel((prev)=>{
+                const fields = _extends({}, prev.fields);
+                delete fields[fieldId];
+                return {
+                    fields,
+                    order: prev.order.filter((id)=>id !== fieldId)
+                };
+            });
+        }, [
+        model,
+        confirm
+    ]);
+    const moveField = useCallback((fieldId, delta)=>()=>setModel((prev)=>{
+                const index = prev.order.indexOf(fieldId);
+                const target = index + delta;
+                if (index < 0 || target < 0 || target >= prev.order.length) return prev;
+                const order = [
+                    ...prev.order
+                ];
+                order.splice(index, 1);
+                order.splice(target, 0, fieldId);
+                return _extends({}, prev, {
+                    order
+                });
+            }), []);
+    const handleSave = useCallback(async ()=>{
+        var _storedScope;
+        if (!dataset || !dataScope) return;
+        /**
+     * What the document actually carries, `[]` when it carries nothing
+     * (AGL-1484) — matching the seed above, through the same helper.
+     *
+     * The pairing is the whole safety property, not tidiness. Both sides
+     * used to substitute `[ORG_SCOPE_TOKEN]`, so an unset dataset compared
+     * equal to itself and merely OPENING the dialog wrote nothing; the
+     * damage was confined to the screen. Correcting the seed alone would
+     * make `scopeChanged` true for every unset dataset the moment its
+     * dialog opened, turning a lie on screen into a write nobody asked for
+     * — one the AGL-1041 rules then reject for any member who is not
+     * org-wide, failing the WHOLE schema save with it.
+     *
+     * `[]` is also the honest previous value in the other direction: a
+     * deliberate save of exactly `['org']` on an unset dataset used to
+     * compare equal to the default and be dropped, and that is the one save
+     * an unstamped dataset most needs to land.
+     */ const previousScope = (_storedScope = storedScope(dataset.visibleTo)) != null ? _storedScope : [];
+        const scopeChanged = JSON.stringify([
+            ...previousScope
+        ].sort()) !== JSON.stringify([
+            ...visibleTo
+        ].sort());
+        /**
+     * The scope this save writes, or null when it writes none.
+     *
+     * Only an org-wide member may change the scope — the AGL-1041 rules deny
+     * anyone else, and a rejected field fails the WHOLE write.
+     *
+     * A selection `scopeToStore` cannot store — "Selected sites…" with no site
+     * picked, or more sites than one query can match — refuses the save rather
+     * than substituting a scope: the org token would share the collection with
+     * every site, and anything narrower would drop sites somebody picked.
+     */ const scopeWrite = orgId && viewerOrgWide && scopeChanged ? scopeToStore(visibleTo) : null;
+        if (scopeWrite == null ? void 0 : scopeWrite.problem) {
+            return void enqueueSnackbar(scopeWrite.problem, {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        if (scopeChanged && narrowsScope(previousScope, visibleTo)) {
+            // Narrowing takes a dataset away from sites whose pages may bind it,
+            // and a repeatable bound to a dataset it can no longer see renders
+            // nothing (AGL-1039). Name the cost before paying it.
+            const losing = orgHostList.filter((host)=>visibleToHost(previousScope, host.$id)).filter((host)=>!visibleToHost(visibleTo, host.$id)).map((host)=>{
+                var _ref, _host_name;
+                return (_ref = (_host_name = host.name) != null ? _host_name : host.subdomain) != null ? _ref : host.$id;
+            });
+            const proceed = await confirm({
+                title: 'Limit which sites can use this collection?',
+                description: losing.length ? `${losing.join(', ')} will stop seeing this collection. Pages ` + 'that repeat over it will render nothing. No data is deleted.' : 'No site loses access, so nothing breaks today.',
+                confirmationText: 'Limit access'
+            }).then(()=>true).catch(()=>false);
+            if (!proceed) return;
+        }
+        if (!model.order.length) {
+            return void enqueueSnackbar('A collection needs at least one field', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        /**
+     * Refuse the write when the seeding listener is unconfirmed (AGL-1358).
+     *
+     * Everything below is seeded from `dataset` and written back whole, so
+     * `updateDoc` field-level merging protects nothing — the untouched
+     * fields are all in the payload. Two of them make a stale seed worse
+     * than an inconvenience:
+     *
+     * - `visibleTo` is the AGL-1041/1042 scoping PREDICATE. Rewriting it
+     *   from a cached seed re-exposes a collection that was narrowed, or
+     *   hides one that was widened, and the confirmation above is computed
+     *   against `previousScope` read from that same stale seed — so it does
+     *   not even warn about the sites it is really taking access from.
+     * - `model` is the entire schema. A cached seed reinstates fields that
+     *   were deleted and drops fields that were added.
+     */ await writeGuardedBySeed({
+            subject: 'collection schema',
+            unreadable: seedUnreadable,
+            fromCache: seedFromCache
+        }, async ()=>void await updateDoc(doc(firestore, dataScope[0], dataScope[1], 'datasets', dataset.$id), _extends({
+                model,
+                names: {
+                    singular: names.singular.trim(),
+                    plural: names.plural.trim()
+                }
+            }, names.plural.trim() ? {
+                displayName: names.plural.trim()
+            } : {}, {
+                // v1 compat: keep the flat column list mirroring the model order
+                // so unmigrated consumers (AGL-103 bindings) keep working.
+                fields: model.order
+            }, (scopeWrite == null ? void 0 : scopeWrite.scope) ? {
+                visibleTo: scopeWrite.scope
+            } : {}))).then((result)=>{
+            // A refusal leaves the dialog open with the edited schema intact.
+            if (!result.ok) {
+                return void enqueueSnackbar(result.message, {
+                    variant: 'warning',
+                    persist: false
+                });
+            }
+            enqueueSnackbar('Schema saved', {
+                variant: 'success',
+                persist: false
+            });
+            onClose();
+        }).catch(()=>enqueueSnackbar('An error has occurred', {
+                variant: 'error'
+            }));
+    }, [
+        dataset,
+        model,
+        names,
+        visibleTo,
+        viewerOrgWide,
+        orgHostList,
+        confirm,
+        firestore,
+        dataScope,
+        orgId,
+        seedFromCache,
+        seedUnreadable,
+        enqueueSnackbar,
+        onClose
+    ]);
+    const editorDefinition = fieldEditor == null ? void 0 : fieldEditor.definition;
+    // Reference ID editing (AGL-578): the id is editable only while creating a
+    // field; live-validate the draft so the input and Save button can react.
+    const isNewField = fieldEditor != null && fieldEditor.fieldId == null;
+    const fieldIdError = fieldEditor && isNewField ? validateDatasetFieldId(fieldEditor.idDraft, new Set(model.order.map((id)=>id.toLowerCase()))) : null;
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(dataset),
+                onClose: onClose,
+                maxWidth: "sm",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: `Schema — ${(_ref = dataset == null ? void 0 : dataset.displayName) != null ? _ref : ''}`
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                sx: {
+                                    mt: 1
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        size: "small",
+                                        label: "Singular name",
+                                        value: names.singular,
+                                        onChange: (event)=>setNames((prev)=>_extends({}, prev, {
+                                                    singular: event.target.value
+                                                })),
+                                        helperText: "e.g. Product"
+                                    }),
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        size: "small",
+                                        label: "Plural name",
+                                        value: names.plural,
+                                        onChange: (event)=>setNames((prev)=>_extends({}, prev, {
+                                                    plural: event.target.value
+                                                })),
+                                        helperText: "e.g. Products (shown as the title)"
+                                    })
+                                ]
+                            }),
+                            orgId ? /*#__PURE__*/ _jsxs(Stack, {
+                                spacing: 0.5,
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "caption",
+                                        color: "text.secondary",
+                                        children: 'Shared with'
+                                    }),
+                                    !scopeLoaded ? /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "body2",
+                                        color: "text.secondary",
+                                        children: 'Checking your access…'
+                                    }) : viewerOrgWide ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                        children: [
+                                            scopeUnset ? /*#__PURE__*/ _jsx(Alert, {
+                                                severity: "warning",
+                                                children: 'This collection has never been shared. Nothing is ' + 'stored, so it is hidden from every site and any ' + 'page repeating over it renders nothing. Choose who ' + 'it is shared with to fix that.'
+                                            }) : null,
+                                            /*#__PURE__*/ _jsxs(Select, {
+                                                size: "small",
+                                                value: visibleTo.includes(ORG_SCOPE_TOKEN) ? 'org' : scopeUnset ? 'unset' : 'hosts',
+                                                onChange: (event)=>{
+                                                    // Any choice ends the unset state — from here the
+                                                    // control shows what was picked, not what was (not)
+                                                    // stored.
+                                                    setScopeUnset(false);
+                                                    setVisibleTo(event.target.value === 'org' ? [
+                                                        ORG_SCOPE_TOKEN
+                                                    ] : []);
+                                                },
+                                                children: [
+                                                    scopeUnset ? /*#__PURE__*/ _jsx(MenuItem, {
+                                                        value: "unset",
+                                                        disabled: true,
+                                                        children: 'Not shared with any site'
+                                                    }) : null,
+                                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                                        value: "org",
+                                                        children: 'All sites'
+                                                    }),
+                                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                                        value: "hosts",
+                                                        children: 'Selected sites…'
+                                                    })
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ _jsx(Typography, {
+                                                variant: "caption",
+                                                color: "text.secondary",
+                                                children: 'Sites you exclude cannot see or use this dataset — in the console or on their pages.'
+                                            }),
+                                            !scopeUnset && !visibleTo.includes(ORG_SCOPE_TOKEN) ? /*#__PURE__*/ _jsx(Stack, {
+                                                direction: "row",
+                                                spacing: 0.5,
+                                                useFlexGap: true,
+                                                sx: {
+                                                    flexWrap: 'wrap'
+                                                },
+                                                children: orgHostList.map((host)=>{
+                                                    var _ref, _host_name;
+                                                    const token = hostScopeToken(host.$id);
+                                                    const on = visibleTo.includes(token);
+                                                    return /*#__PURE__*/ _jsx(Chip, {
+                                                        size: "small",
+                                                        label: (_ref = (_host_name = host.name) != null ? _host_name : host.subdomain) != null ? _ref : host.$id,
+                                                        color: on ? 'primary' : 'default',
+                                                        variant: on ? 'filled' : 'outlined',
+                                                        onClick: ()=>setVisibleTo((prev)=>on ? prev.filter((t)=>t !== token) : [
+                                                                    ...prev,
+                                                                    token
+                                                                ])
+                                                    }, host.$id);
+                                                })
+                                            }) : null,
+                                            !scopeUnset && scopeToStore(visibleTo).problem ? /*#__PURE__*/ _jsx(Typography, {
+                                                variant: "caption",
+                                                color: "error",
+                                                children: scopeToStore(visibleTo).problem
+                                            }) : null
+                                        ]
+                                    }) : /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "body2",
+                                        children: scopeUnset ? 'Never shared — hidden from every site' : describeScope(visibleTo, Object.fromEntries(orgHostList.map((host)=>{
+                                            var _ref, _host_name;
+                                            return [
+                                                host.$id,
+                                                (_ref = (_host_name = host.name) != null ? _host_name : host.subdomain) != null ? _ref : host.$id
+                                            ];
+                                        })))
+                                    })
+                                ]
+                            }) : null,
+                            /*#__PURE__*/ _jsx(Stack, {
+                                spacing: 0.5,
+                                children: model.order.map((fieldId, index)=>{
+                                    var _DATASET_FIELD_TYPE_LABELS_field_type;
+                                    var _field_validation;
+                                    const field = model.fields[fieldId];
+                                    if (!field) return null;
+                                    return /*#__PURE__*/ _jsxs(Stack, {
+                                        direction: "row",
+                                        spacing: 1,
+                                        sx: {
+                                            alignItems: 'center',
+                                            px: 1,
+                                            py: 0.5,
+                                            border: '1px solid',
+                                            borderColor: 'divider',
+                                            borderRadius: 1
+                                        },
+                                        children: [
+                                            /*#__PURE__*/ _jsxs(Stack, {
+                                                sx: {
+                                                    flex: 1,
+                                                    minWidth: 0
+                                                },
+                                                children: [
+                                                    /*#__PURE__*/ _jsxs(Typography, {
+                                                        variant: "body2",
+                                                        noWrap: true,
+                                                        children: [
+                                                            field.name,
+                                                            /*#__PURE__*/ _jsx(Typography, {
+                                                                component: "span",
+                                                                variant: "caption",
+                                                                color: "text.secondary",
+                                                                children: ` · ${fieldId}`
+                                                            })
+                                                        ]
+                                                    }),
+                                                    field.description ? /*#__PURE__*/ _jsx(Typography, {
+                                                        variant: "caption",
+                                                        color: "text.secondary",
+                                                        noWrap: true,
+                                                        children: field.description
+                                                    }) : null
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ _jsx(Chip, {
+                                                size: "small",
+                                                label: (_DATASET_FIELD_TYPE_LABELS_field_type = DATASET_FIELD_TYPE_LABELS[field.type]) != null ? _DATASET_FIELD_TYPE_LABELS_field_type : field.type
+                                            }),
+                                            field.required || ((_field_validation = field.validation) == null ? void 0 : _field_validation.required) ? /*#__PURE__*/ _jsx(Chip, {
+                                                size: "small",
+                                                color: "primary",
+                                                label: "required"
+                                            }) : null,
+                                            /*#__PURE__*/ _jsx(IconButton, {
+                                                size: "small",
+                                                disabled: index === 0,
+                                                onClick: moveField(fieldId, -1),
+                                                "aria-label": "Move up",
+                                                children: '▲'
+                                            }),
+                                            /*#__PURE__*/ _jsx(IconButton, {
+                                                size: "small",
+                                                disabled: index === model.order.length - 1,
+                                                onClick: moveField(fieldId, 1),
+                                                "aria-label": "Move down",
+                                                children: '▼'
+                                            }),
+                                            /*#__PURE__*/ _jsx(Button, {
+                                                size: "small",
+                                                onClick: openFieldEditor(fieldId),
+                                                children: 'Edit'
+                                            }),
+                                            /*#__PURE__*/ _jsx(Button, {
+                                                size: "small",
+                                                color: "error",
+                                                onClick: handleFieldRemove(fieldId),
+                                                children: 'Remove'
+                                            })
+                                        ]
+                                    }, fieldId);
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                variant: "outlined",
+                                color: "primary",
+                                onClick: openFieldEditor(null),
+                                sx: {
+                                    alignSelf: 'flex-start'
+                                },
+                                children: 'Add field'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: onClose,
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !dataScope,
+                                onClick: handleSave,
+                                children: 'Save schema'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(fieldEditor),
+                onClose: ()=>setFieldEditor(null),
+                maxWidth: "xs",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: (fieldEditor == null ? void 0 : fieldEditor.fieldId) ? 'Edit field' : 'New field'
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                size: "small",
+                                label: "Display name",
+                                value: (_ref1 = editorDefinition == null ? void 0 : editorDefinition.name) != null ? _ref1 : '',
+                                autoFocus: true,
+                                onChange: (event)=>{
+                                    const name = event.target.value;
+                                    setFieldEditor((prev)=>{
+                                        if (!prev) return prev;
+                                        const next = _extends({}, prev, {
+                                            definition: _extends({}, prev.definition, {
+                                                name
+                                            })
+                                        });
+                                        // The reference id follows the display name until the user
+                                        // edits it (new fields only) — AGL-578.
+                                        if (prev.fieldId == null && !prev.idTouched) {
+                                            next.idDraft = defaultDatasetFieldId(name, new Set(model.order.map((id)=>id.toLowerCase())));
+                                        }
+                                        return next;
+                                    });
+                                },
+                                sx: {
+                                    mt: 1
+                                },
+                                helperText: "Shown to people editing records and wherever the field appears"
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                size: "small",
+                                label: "Reference ID",
+                                value: isNewField ? (_ref2 = fieldEditor == null ? void 0 : fieldEditor.idDraft) != null ? _ref2 : '' : (_ref3 = fieldEditor == null ? void 0 : fieldEditor.fieldId) != null ? _ref3 : '',
+                                disabled: !isNewField,
+                                onChange: (event)=>setFieldEditor((prev)=>prev ? _extends({}, prev, {
+                                            idDraft: event.target.value,
+                                            idTouched: true
+                                        }) : prev),
+                                error: Boolean(fieldIdError),
+                                helperText: isNewField ? fieldIdError != null ? fieldIdError : 'Stable key used in bindings ({{item.id}}), forms, and imports. Auto-filled from the display name — edit to override. Fixed once the field is created.' : 'Reference IDs are stable keys and cannot change after creation'
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                size: "small",
+                                label: "Description",
+                                multiline: true,
+                                minRows: 2,
+                                value: (_ref4 = editorDefinition == null ? void 0 : editorDefinition.description) != null ? _ref4 : '',
+                                onChange: (event)=>setFieldEditor((prev)=>prev ? _extends({}, prev, {
+                                            definition: _extends({}, prev.definition, {
+                                                description: event.target.value
+                                            })
+                                        }) : prev),
+                                helperText: "What this field is for — shown as a hint wherever the field appears"
+                            }),
+                            /*#__PURE__*/ _jsxs(TextField, {
+                                select: true,
+                                size: "small",
+                                label: "Type",
+                                value: (editorDefinition == null ? void 0 : editorDefinition.customType) ? `custom:${editorDefinition.customType}` : (_ref5 = editorDefinition == null ? void 0 : editorDefinition.type) != null ? _ref5 : 'text',
+                                onChange: (event)=>setFieldEditor((prev)=>{
+                                        if (!prev) return prev;
+                                        const selected = event.target.value;
+                                        // Custom field types (AGL-434): ride a base storage type
+                                        // and stamp customType so the record editor + validators
+                                        // pick up the plugin behavior.
+                                        if (selected.startsWith('custom:')) {
+                                            const fieldType = getCustomFieldType(selected.slice(7));
+                                            if (!fieldType) return prev;
+                                            return _extends({}, prev, {
+                                                definition: _extends({}, prev.definition, {
+                                                    type: fieldType.baseType,
+                                                    customType: fieldType.name
+                                                })
+                                            });
+                                        }
+                                        const definition = _extends({}, prev.definition, {
+                                            type: selected
+                                        });
+                                        delete definition.customType;
+                                        return _extends({}, prev, {
+                                            definition
+                                        });
+                                    }),
+                                children: [
+                                    ((fieldEditor == null ? void 0 : fieldEditor.fieldId) && editorDefinition && !AUTHORABLE_TYPES.includes(editorDefinition.type) ? DATASET_FIELD_TYPES : AUTHORABLE_TYPES).map((type)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                            value: type,
+                                            children: DATASET_FIELD_TYPE_LABELS[type]
+                                        }, type)),
+                                    listCustomFieldTypes().map((fieldType)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                            value: `custom:${fieldType.name}`,
+                                            children: `${fieldType.label} (${fieldType.pluginId})`
+                                        }, `custom:${fieldType.name}`))
+                                ]
+                            }),
+                            (editorDefinition == null ? void 0 : editorDefinition.type) === 'reference' ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        select: true,
+                                        size: "small",
+                                        label: "Target collection",
+                                        value: (_ref6 = editorDefinition == null ? void 0 : (_editorDefinition_reference = editorDefinition.reference) == null ? void 0 : _editorDefinition_reference.datasetId) != null ? _ref6 : '',
+                                        onChange: (event)=>setFieldEditor((prev)=>{
+                                                var _prev_definition_reference;
+                                                return prev ? _extends({}, prev, {
+                                                    definition: _extends({}, prev.definition, {
+                                                        reference: _extends({}, (_prev_definition_reference = prev.definition.reference) != null ? _prev_definition_reference : {
+                                                            datasetId: ''
+                                                        }, {
+                                                            datasetId: event.target.value
+                                                        })
+                                                    })
+                                                }) : prev;
+                                            }),
+                                        children: (datasets != null ? datasets : []).filter((target)=>target.$id !== (dataset == null ? void 0 : dataset.$id))// Only targets this dataset's sites can actually resolve
+                                        // (AGL-1044). A reference to a dataset a site cannot see
+                                        // renders blank with nothing to say why, so an
+                                        // unresolvable target is not offered. The currently
+                                        // selected one always stays listed — otherwise changing
+                                        // scope would silently blank an existing field.
+                                        .filter((target)=>{
+                                            var _editorDefinition_reference;
+                                            return target.$id === (editorDefinition == null ? void 0 : (_editorDefinition_reference = editorDefinition.reference) == null ? void 0 : _editorDefinition_reference.datasetId) || scopeCovers(target.visibleTo, visibleTo);
+                                        }).map((target)=>{
+                                            var _target_displayName;
+                                            return /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: target.$id,
+                                                children: (_target_displayName = target.displayName) != null ? _target_displayName : target.$id
+                                            }, target.$id);
+                                        })
+                                    }),
+                                    (()=>{
+                                        var _target_displayName;
+                                        var _editorDefinition_reference;
+                                        // Flag an EXISTING reference that this dataset's scope has
+                                        // outgrown — the field was valid when created and quietly
+                                        // is not any more.
+                                        const targetId = editorDefinition == null ? void 0 : (_editorDefinition_reference = editorDefinition.reference) == null ? void 0 : _editorDefinition_reference.datasetId;
+                                        const target = (datasets != null ? datasets : []).find((d)=>d.$id === targetId);
+                                        if (!target || scopeCovers(target.visibleTo, visibleTo)) {
+                                            return null;
+                                        }
+                                        return /*#__PURE__*/ _jsx(Alert, {
+                                            severity: "warning",
+                                            children: `"${(_target_displayName = target.displayName) != null ? _target_displayName : target.$id}" is not shared with ` + 'every site this collection is. Those sites will show ' + 'this field blank. Widen its sharing, or narrow this ' + "collection's."
+                                        });
+                                    })(),
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        select: true,
+                                        size: "small",
+                                        label: "Display field",
+                                        value: (_ref7 = editorDefinition == null ? void 0 : (_editorDefinition_reference1 = editorDefinition.reference) == null ? void 0 : _editorDefinition_reference1.displayFieldId) != null ? _ref7 : '',
+                                        onChange: (event)=>setFieldEditor((prev)=>(prev == null ? void 0 : prev.definition.reference) ? _extends({}, prev, {
+                                                    definition: _extends({}, prev.definition, {
+                                                        reference: _extends({}, prev.definition.reference, {
+                                                            displayFieldId: event.target.value
+                                                        })
+                                                    })
+                                                }) : prev),
+                                        helperText: "Shown in pickers and grid cells",
+                                        children: effectiveDatasetModel((_find = (datasets != null ? datasets : []).find((target)=>{
+                                            var _editorDefinition_reference;
+                                            return target.$id === (editorDefinition == null ? void 0 : (_editorDefinition_reference = editorDefinition.reference) == null ? void 0 : _editorDefinition_reference.datasetId);
+                                        })) != null ? _find : {}).order.map((targetFieldId)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                                value: targetFieldId,
+                                                children: targetFieldId
+                                            }, targetFieldId))
+                                    }),
+                                    /*#__PURE__*/ _jsxs(TextField, {
+                                        select: true,
+                                        size: "small",
+                                        label: "When a referenced document is deleted",
+                                        value: (_ref8 = editorDefinition == null ? void 0 : (_editorDefinition_reference2 = editorDefinition.reference) == null ? void 0 : _editorDefinition_reference2.onDelete) != null ? _ref8 : 'setNull',
+                                        onChange: (event)=>setFieldEditor((prev)=>(prev == null ? void 0 : prev.definition.reference) ? _extends({}, prev, {
+                                                    definition: _extends({}, prev.definition, {
+                                                        reference: _extends({}, prev.definition.reference, {
+                                                            onDelete: event.target.value
+                                                        })
+                                                    })
+                                                }) : prev),
+                                        children: [
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "setNull",
+                                                children: 'Clear the reference'
+                                            }),
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "restrict",
+                                                children: 'Block the delete'
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ _jsx(FormControlLabel, {
+                                        control: /*#__PURE__*/ _jsx(Checkbox, {
+                                            size: "small",
+                                            checked: Boolean(editorDefinition == null ? void 0 : (_editorDefinition_reference3 = editorDefinition.reference) == null ? void 0 : _editorDefinition_reference3.multiple),
+                                            onChange: (event)=>setFieldEditor((prev)=>(prev == null ? void 0 : prev.definition.reference) ? _extends({}, prev, {
+                                                        definition: _extends({}, prev.definition, {
+                                                            reference: _extends({}, prev.definition.reference, {
+                                                                multiple: event.target.checked
+                                                            })
+                                                        })
+                                                    }) : prev)
+                                        }),
+                                        label: "Allow multiple (many-to-many)"
+                                    })
+                                ]
+                            }) : null,
+                            /*#__PURE__*/ _jsx(FormControlLabel, {
+                                control: /*#__PURE__*/ _jsx(Checkbox, {
+                                    size: "small",
+                                    checked: Boolean(editorDefinition == null ? void 0 : editorDefinition.required),
+                                    onChange: (event)=>setFieldEditor((prev)=>prev ? _extends({}, prev, {
+                                                definition: _extends({}, prev.definition, {
+                                                    required: event.target.checked
+                                                })
+                                            }) : prev)
+                                }),
+                                label: "Required"
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                size: "small",
+                                label: "Default value",
+                                value: String((_ref9 = editorDefinition == null ? void 0 : editorDefinition.default) != null ? _ref9 : ''),
+                                onChange: (event)=>setFieldEditor((prev)=>prev ? _extends({}, prev, {
+                                            definition: _extends({}, prev.definition, event.target.value ? {
+                                                default: event.target.value
+                                            } : {
+                                                default: undefined
+                                            })
+                                        }) : prev),
+                                helperText: "Pre-filled when creating documents"
+                            }),
+                            (editorDefinition == null ? void 0 : editorDefinition.type) === 'text' ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        size: "small",
+                                        label: "Pattern (regex)",
+                                        value: (_ref10 = editorDefinition == null ? void 0 : (_editorDefinition_validation = editorDefinition.validation) == null ? void 0 : _editorDefinition_validation.regex) != null ? _ref10 : '',
+                                        onChange: (event)=>setFieldEditor((prev)=>{
+                                                var _prev_definition_validation;
+                                                return prev ? _extends({}, prev, {
+                                                    definition: _extends({}, prev.definition, {
+                                                        validation: _extends({}, (_prev_definition_validation = prev.definition.validation) != null ? _prev_definition_validation : {}, event.target.value ? {
+                                                            regex: event.target.value
+                                                        } : {
+                                                            regex: undefined
+                                                        })
+                                                    })
+                                                }) : prev;
+                                            })
+                                    }),
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        size: "small",
+                                        label: "Options",
+                                        value: (_ref11 = fieldEditor == null ? void 0 : fieldEditor.optionsText) != null ? _ref11 : '',
+                                        onChange: (event)=>setFieldEditor((prev)=>prev ? _extends({}, prev, {
+                                                    optionsText: event.target.value
+                                                }) : prev),
+                                        helperText: "Comma-separated enum, e.g. basic, plus"
+                                    })
+                                ]
+                            }) : null,
+                            editorDefinition && [
+                                'int32',
+                                'int64',
+                                'float',
+                                'timestamp',
+                                'text'
+                            ].includes(editorDefinition.type) ? /*#__PURE__*/ _jsx(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                children: [
+                                    'min',
+                                    'max'
+                                ].map((bound)=>{
+                                    var _ref;
+                                    var _editorDefinition_validation;
+                                    return /*#__PURE__*/ _jsx(TextField, {
+                                        size: "small",
+                                        type: "number",
+                                        label: editorDefinition.type === 'text' ? `${bound === 'min' ? 'Min' : 'Max'} length` : bound === 'min' ? 'Min' : 'Max',
+                                        value: (_ref = (_editorDefinition_validation = editorDefinition.validation) == null ? void 0 : _editorDefinition_validation[bound]) != null ? _ref : '',
+                                        onChange: (event)=>setFieldEditor((prev)=>{
+                                                var _prev_definition_validation;
+                                                return prev ? _extends({}, prev, {
+                                                    definition: _extends({}, prev.definition, {
+                                                        validation: _extends({}, (_prev_definition_validation = prev.definition.validation) != null ? _prev_definition_validation : {}, event.target.value === '' ? {
+                                                            [bound]: undefined
+                                                        } : {
+                                                            [bound]: Number(event.target.value)
+                                                        })
+                                                    })
+                                                }) : prev;
+                                            })
+                                    }, bound);
+                                })
+                            }) : null
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setFieldEditor(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !(editorDefinition == null ? void 0 : editorDefinition.name.trim()) || Boolean(fieldIdError),
+                                onClick: handleFieldSave,
+                                children: (fieldEditor == null ? void 0 : fieldEditor.fieldId) ? 'Save field' : 'Add field'
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+}
+DatasetSchemaDialog.displayName = 'DatasetSchemaDialog';
+export default DatasetSchemaDialog;
+
+//# sourceMappingURL=dataset-schema-dialog.component.js.map