@aglyn/plugins-data 1.0.0-beta.221 → 1.0.0-beta.223

package/src/lib/record-pages/record-template-row-chip.component.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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.
+ */
+import type { ConsoleHostScreenRowZoneProps } from '@aglyn/aglyn/plugin-manager/feature-plugins';
+/**
+ * A Pages list row's record template chip (AGL-3475): how many record pages the
+ * page serves, with the base they live under in its tooltip — what an author
+ * scanning the list needs to know about a page that has no address of its own.
+ *
+ * The site's bindings come from one query however many rows ask, which the
+ * Firestore SDK shares between identical listeners; only a row that IS a
+ * record template reads anything more, and that is one count.
+ */
+export declare function RecordTemplateRowChip(props: ConsoleHostScreenRowZoneProps): import("react").JSX.Element;
+export default RecordTemplateRowChip;

package/src/lib/record-pages/record-template-row-chip.component.js

@@ -0,0 +1,87 @@
+/**
+ * @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 { jsx as _jsx } from "react/jsx-runtime";
+import { useFirestore, useOrgDataScope } from "@aglyn/tenant-feature-instance";
+import { Chip, Tooltip } from "@mui/material";
+import { collection, doc, getCountFromServer, getDoc } from "firebase/firestore";
+import { useEffect, useState } from "react";
+import { datasetDisplayName } from "../model/datasets.js";
+import { useSiteRecordPageBindings } from "./record-page-source.js";
+/**
+ * A Pages list row's record template chip (AGL-3475): how many record pages the
+ * page serves, with the base they live under in its tooltip — what an author
+ * scanning the list needs to know about a page that has no address of its own.
+ *
+ * The site's bindings come from one query however many rows ask, which the
+ * Firestore SDK shares between identical listeners; only a row that IS a
+ * record template reads anything more, and that is one count.
+ */ export function RecordTemplateRowChip(props) {
+    const { hostId, orgId, screenId } = props;
+    const { bindings } = useSiteRecordPageBindings(hostId);
+    const binding = bindings.find((one)=>one.screenId === screenId);
+    const firestore = useFirestore();
+    const { scope } = useOrgDataScope({
+        hostId,
+        orgId
+    });
+    const [summary, setSummary] = useState(null);
+    const datasetId = binding == null ? void 0 : binding.datasetId;
+    useEffect(()=>{
+        if (!datasetId || !scope) {
+            setSummary(null);
+            return undefined;
+        }
+        let active = true;
+        const datasetRef = doc(firestore, scope[0], scope[1], 'datasets', datasetId);
+        Promise.all([
+            getDoc(datasetRef),
+            getCountFromServer(collection(datasetRef, 'records'))
+        ]).then(([dataset, count])=>{
+            if (!active) return;
+            setSummary({
+                name: datasetDisplayName(dataset.data()),
+                count: count.data().count
+            });
+        }).catch((error)=>{
+            // A dataset this viewer may not read still gets its chip, unnumbered.
+            console.error(error);
+            if (active) setSummary(null);
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        firestore,
+        scope,
+        datasetId
+    ]);
+    if (!binding) return null;
+    // Short, because it shares the name's cell: the count is the news, and the
+    // tooltip says where the pages live.
+    const label = summary ? `${summary.count} record ${summary.count === 1 ? 'page' : 'pages'}` : 'Record template';
+    return /*#__PURE__*/ _jsx(Tooltip, {
+        title: `Record template${(summary == null ? void 0 : summary.name) ? ` of ${summary.name}` : ''}: served once per record at /${binding.base}/ and each record's page address`,
+        children: /*#__PURE__*/ _jsx(Chip, {
+            size: "small",
+            variant: "outlined",
+            label: label
+        })
+    });
+}
+export default RecordTemplateRowChip;
+
+//# sourceMappingURL=record-template-row-chip.component.js.map

package/src/lib/record-pages/record-template-row-chip.component.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/data/src/lib/record-pages/record-template-row-chip.component.tsx"],"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'use client'\n\nimport type { ConsoleHostScreenRowZoneProps } from '@aglyn/aglyn/plugin-manager/feature-plugins'\nimport { useFirestore, useOrgDataScope } from '@aglyn/tenant-feature-instance'\nimport { Chip, Tooltip } from '@mui/material'\nimport { collection, doc, getCountFromServer, getDoc } from 'firebase/firestore'\nimport { useEffect, useState } from 'react'\nimport { datasetDisplayName, type HostDataset } from '../model/datasets'\nimport { useSiteRecordPageBindings } from './record-page-source'\n\n/**\n * A Pages list row's record template chip (AGL-3475): how many record pages the\n * page serves, with the base they live under in its tooltip — what an author\n * scanning the list needs to know about a page that has no address of its own.\n *\n * The site's bindings come from one query however many rows ask, which the\n * Firestore SDK shares between identical listeners; only a row that IS a\n * record template reads anything more, and that is one count.\n */\nexport function RecordTemplateRowChip(props: ConsoleHostScreenRowZoneProps) {\n  const { hostId, orgId, screenId } = props\n  const { bindings } = useSiteRecordPageBindings(hostId)\n  const binding = bindings.find((one) => one.screenId === screenId)\n  const firestore = useFirestore()\n  const { scope } = useOrgDataScope({ hostId, orgId })\n  const [summary, setSummary] = useState<{ name: string; count: number } | null>(null)\n  const datasetId = binding?.datasetId\n\n  useEffect(() => {\n    if (!datasetId || !scope) {\n      setSummary(null)\n      return undefined\n    }\n    let active = true\n    const datasetRef = doc(firestore, scope[0], scope[1], 'datasets', datasetId)\n    Promise.all([getDoc(datasetRef), getCountFromServer(collection(datasetRef, 'records'))])\n      .then(([dataset, count]) => {\n        if (!active) return\n        setSummary({\n          name: datasetDisplayName(dataset.data() as HostDataset | undefined),\n          count: count.data().count,\n        })\n      })\n      .catch((error) => {\n        // A dataset this viewer may not read still gets its chip, unnumbered.\n        console.error(error)\n        if (active) setSummary(null)\n      })\n    return () => {\n      active = false\n    }\n  }, [firestore, scope, datasetId])\n\n  if (!binding) return null\n  // Short, because it shares the name's cell: the count is the news, and the\n  // tooltip says where the pages live.\n  const label = summary\n    ? `${summary.count} record ${summary.count === 1 ? 'page' : 'pages'}`\n    : 'Record template'\n  return (\n    <Tooltip\n      title={`Record template${summary?.name ? ` of ${summary.name}` : ''}: served once per record at /${binding.base}/ and each record's page address`}\n    >\n      <Chip size=\"small\" variant=\"outlined\" label={label} />\n    </Tooltip>\n  )\n}\n\nexport default RecordTemplateRowChip\n"],"names":["useFirestore","useOrgDataScope","Chip","Tooltip","collection","doc","getCountFromServer","getDoc","useEffect","useState","datasetDisplayName","useSiteRecordPageBindings","RecordTemplateRowChip","props","hostId","orgId","screenId","bindings","binding","find","one","firestore","scope","summary","setSummary","datasetId","undefined","active","datasetRef","Promise","all","then","dataset","count","name","data","catch","error","console","label","title","base","size","variant"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;AAGA,SAASA,YAAY,EAAEC,eAAe,QAAQ,iCAAgC;AAC9E,SAASC,IAAI,EAAEC,OAAO,QAAQ,gBAAe;AAC7C,SAASC,UAAU,EAAEC,GAAG,EAAEC,kBAAkB,EAAEC,MAAM,QAAQ,qBAAoB;AAChF,SAASC,SAAS,EAAEC,QAAQ,QAAQ,QAAO;AAC3C,SAASC,kBAAkB,QAA0B,uBAAmB;AACxE,SAASC,yBAAyB,QAAQ,0BAAsB;AAEhE;;;;;;;;CAQC,GACD,OAAO,SAASC,sBAAsBC,KAAoC;IACxE,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGH;IACpC,MAAM,EAAEI,QAAQ,EAAE,GAAGN,0BAA0BG;IAC/C,MAAMI,UAAUD,SAASE,IAAI,CAAC,CAACC,MAAQA,IAAIJ,QAAQ,KAAKA;IACxD,MAAMK,YAAYrB;IAClB,MAAM,EAAEsB,KAAK,EAAE,GAAGrB,gBAAgB;QAAEa;QAAQC;IAAM;IAClD,MAAM,CAACQ,SAASC,WAAW,GAAGf,SAAiD;IAC/E,MAAMgB,YAAYP,2BAAAA,QAASO,SAAS;IAEpCjB,UAAU;QACR,IAAI,CAACiB,aAAa,CAACH,OAAO;YACxBE,WAAW;YACX,OAAOE;QACT;QACA,IAAIC,SAAS;QACb,MAAMC,aAAavB,IAAIgB,WAAWC,KAAK,CAAC,EAAE,EAAEA,KAAK,CAAC,EAAE,EAAE,YAAYG;QAClEI,QAAQC,GAAG,CAAC;YAACvB,OAAOqB;YAAatB,mBAAmBF,WAAWwB,YAAY;SAAY,EACpFG,IAAI,CAAC,CAAC,CAACC,SAASC,MAAM;YACrB,IAAI,CAACN,QAAQ;YACbH,WAAW;gBACTU,MAAMxB,mBAAmBsB,QAAQG,IAAI;gBACrCF,OAAOA,MAAME,IAAI,GAAGF,KAAK;YAC3B;QACF,GACCG,KAAK,CAAC,CAACC;YACN,sEAAsE;YACtEC,QAAQD,KAAK,CAACA;YACd,IAAIV,QAAQH,WAAW;QACzB;QACF,OAAO;YACLG,SAAS;QACX;IACF,GAAG;QAACN;QAAWC;QAAOG;KAAU;IAEhC,IAAI,CAACP,SAAS,OAAO;IACrB,2EAA2E;IAC3E,qCAAqC;IACrC,MAAMqB,QAAQhB,UACV,GAAGA,QAAQU,KAAK,CAAC,QAAQ,EAAEV,QAAQU,KAAK,KAAK,IAAI,SAAS,SAAS,GACnE;IACJ,qBACE,KAAC9B;QACCqC,OAAO,CAAC,eAAe,EAAEjB,CAAAA,2BAAAA,QAASW,IAAI,IAAG,CAAC,IAAI,EAAEX,QAAQW,IAAI,EAAE,GAAG,GAAG,6BAA6B,EAAEhB,QAAQuB,IAAI,CAAC,gCAAgC,CAAC;kBAEjJ,cAAA,KAACvC;YAAKwC,MAAK;YAAQC,SAAQ;YAAWJ,OAAOA;;;AAGnD;AAEA,eAAe3B,sBAAqB"}

package/src/lib/record-pages/record-template-section.component.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @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.
+ */
+import type { ConsoleBesignerPagePropertiesZoneProps } from '@aglyn/aglyn/plugin-manager/feature-plugins';
+/**
+ * Page Properties' "Record pages" section (AGL-3475): makes the page in the
+ * editor the record template of a dataset, so it is served once per record at
+ * `/{base}/{address}`, and picks the record the canvas draws it for.
+ *
+ * Saving a page that is not yet a template converts it first, through the
+ * platform's own route, after saying what that means: it stops answering at
+ * its own address and stops counting toward the plan's pages. The binding is
+ * then written by the record-pages route, which re-checks everything this
+ * section checks and the few things only the server can see.
+ */
+export declare function RecordTemplateSection(props: ConsoleBesignerPagePropertiesZoneProps): import("react").JSX.Element;
+export default RecordTemplateSection;

package/src/lib/record-pages/record-template-section.component.js

@@ -0,0 +1,491 @@
+/**
+ * @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 { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { checkEntitlement, scopeTokensForHost } from "@aglyn/aglyn";
+import { useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { authorizedFetch } from "@aglyn/shared-util-http/authorized-token";
+import { useFirestore, useFirestoreCollection, useOrgDataScope, useOrgPlan, useUser } from "@aglyn/tenant-feature-instance";
+import { Button, InputAdornment, MenuItem, Stack, TextField, Typography } from "@mui/material";
+import { collection, limit, query, where } from "firebase/firestore";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { effectiveDatasetModel } from "../model/dataset-models.js";
+import { datasetDisplayName } from "../model/datasets.js";
+import { isRecordAddressField, recordAddressFieldIds, recordPageBaseRefusal, recordPagePath } from "./record-pages.js";
+import { useRecordPagePreview, useSiteRecordPageBindings } from "./record-page-source.js";
+/** The optional field pickers, in the order the section offers them. */ const FIELD_PICKERS = [
+    {
+        key: 'titleField',
+        label: 'Page name from',
+        helper: 'Names each page — its tab title and breadcrumb. Defaults to the first text field.',
+        empty: 'First text field'
+    },
+    {
+        key: 'seoTitleField',
+        label: 'Search title from',
+        helper: 'Used exactly as written. Without one, the page name and the site title are used.',
+        empty: 'Page name'
+    },
+    {
+        key: 'seoDescriptionField',
+        label: 'Search description from',
+        helper: 'Without one, this page’s own description is used.',
+        empty: 'This page’s description'
+    },
+    {
+        key: 'seoImageField',
+        label: 'Sharing image from',
+        helper: 'A media field or an image URL. Without one, this page’s image is used.',
+        empty: 'This page’s image'
+    }
+];
+const EMPTY_DRAFT = {
+    datasetId: '',
+    base: '',
+    slugField: ''
+};
+/**
+ * Page Properties' "Record pages" section (AGL-3475): makes the page in the
+ * editor the record template of a dataset, so it is served once per record at
+ * `/{base}/{address}`, and picks the record the canvas draws it for.
+ *
+ * Saving a page that is not yet a template converts it first, through the
+ * platform's own route, after saying what that means: it stops answering at
+ * its own address and stops counting toward the plan's pages. The binding is
+ * then written by the record-pages route, which re-checks everything this
+ * section checks and the few things only the server can see.
+ */ export function RecordTemplateSection(props) {
+    const { hostId, orgId, screenId, screenKind } = props;
+    const firestore = useFirestore();
+    const { data: user } = useUser();
+    const { enqueueSnackbar } = useSnackbar();
+    const { confirm } = useConfirmationContext();
+    const { org, ready: planReady } = useOrgPlan(hostId);
+    const { scope } = useOrgDataScope({
+        hostId,
+        orgId
+    });
+    const { bindings } = useSiteRecordPageBindings(hostId);
+    const current = bindings.find((binding)=>binding.screenId === screenId);
+    const preview = useRecordPagePreview({
+        hostId,
+        screenId
+    });
+    // The datasets THIS site may see, which are the ones a record page can
+    // render: the same scope the published page's reads apply.
+    const { data: datasetDocs } = useFirestoreCollection(()=>scope ? query(collection(firestore, scope[0], scope[1], 'datasets'), where('visibleTo', 'array-contains-any', scopeTokensForHost(hostId)), limit(100)) : null, [
+        firestore,
+        scope,
+        hostId
+    ], {
+        idField: '$id'
+    });
+    const datasets = useMemo(()=>(datasetDocs != null ? datasetDocs : []).filter((dataset)=>!dataset.deletedAt).sort((a, b)=>datasetDisplayName(a).localeCompare(datasetDisplayName(b))), [
+        datasetDocs
+    ]);
+    const [draft, setDraft] = useState(EMPTY_DRAFT);
+    const [sourceField, setSourceField] = useState('');
+    const [busy, setBusy] = useState(false);
+    useEffect(()=>{
+        if (current) {
+            const { screenId: _id } = current, stored = _object_without_properties_loose(current, [
+                "screenId"
+            ]);
+            setDraft(stored);
+        } else {
+            setDraft(EMPTY_DRAFT);
+        }
+    }, [
+        current
+    ]);
+    const dataset = datasets.find((one)=>one.$id === draft.datasetId);
+    const model = dataset ? effectiveDatasetModel(dataset) : undefined;
+    const addressFields = model ? recordAddressFieldIds(model) : [];
+    const textFields = model ? model.order.filter((fieldId)=>{
+        var _model_fields_fieldId;
+        return ((_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.type) === 'text' && !isRecordAddressField(model.fields[fieldId]);
+    }) : [];
+    const baseRefusal = draft.base ? recordPageBaseRefusal(draft.base, {
+        otherBases: bindings.filter((binding)=>binding.screenId !== screenId).map((binding)=>binding.base)
+    }) : null;
+    // A dataset with exactly one address field needs no choice.
+    useEffect(()=>{
+        if (model && !draft.slugField && addressFields.length === 1) {
+            setDraft((previous)=>_extends({}, previous, {
+                    slugField: addressFields[0]
+                }));
+        }
+    }, [
+        model,
+        draft.slugField,
+        addressFields
+    ]);
+    const post = useCallback(async (path, body)=>{
+        var _ref;
+        const response = await authorizedFetch(user, path, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(body)
+        });
+        const result = await response.json().catch(()=>({}));
+        if (!response.ok) throw new Error((_ref = result == null ? void 0 : result['error']) != null ? _ref : 'Something went wrong');
+        return result;
+    }, [
+        user
+    ]);
+    const handleAddAddresses = useCallback(async ()=>{
+        if (!dataset || !sourceField || !orgId) return;
+        setBusy(true);
+        try {
+            const result = await post('/api/orgs/datasets', {
+                orgId,
+                action: 'add-address-field',
+                datasetId: dataset.$id,
+                sourceField
+            });
+            setDraft((previous)=>{
+                var _result_fieldId;
+                return _extends({}, previous, {
+                    slugField: String((_result_fieldId = result['fieldId']) != null ? _result_fieldId : '')
+                });
+            });
+            enqueueSnackbar(result['truncated'] ? `Gave ${result['filled']} records a page address — run it again for the rest` : `Gave ${result['filled']} records a page address`, {
+                variant: 'success'
+            });
+        } catch (error) {
+            enqueueSnackbar(error.message, {
+                variant: 'error'
+            });
+        } finally{
+            setBusy(false);
+        }
+    }, [
+        dataset,
+        sourceField,
+        orgId,
+        post,
+        enqueueSnackbar
+    ]);
+    const handleSave = useCallback(async ()=>{
+        if (screenKind !== 'template') {
+            const accepted = await confirm({
+                title: 'Make this page a record template?',
+                description: `Each record gets its own page at ${recordPagePath(draft.base || 'base', 'address')}, ` + 'drawn by this design. This page stops answering at its own address and no ' + 'longer counts toward your plan’s pages.',
+                confirmationText: 'Make it a template'
+            })// The dialog rejects on cancel.
+            .then(()=>true).catch(()=>false);
+            if (!accepted) return;
+        }
+        setBusy(true);
+        try {
+            if (screenKind !== 'template') {
+                await post('/api/hosts/screens', {
+                    action: 'convert',
+                    hostId,
+                    id: screenId,
+                    kind: 'template'
+                });
+            }
+            await post('/api/hosts/record-pages', _extends({
+                action: 'save',
+                hostId,
+                screenId
+            }, draft));
+            enqueueSnackbar('Record pages saved', {
+                variant: 'success'
+            });
+        } catch (error) {
+            enqueueSnackbar(error.message, {
+                variant: 'error'
+            });
+        } finally{
+            setBusy(false);
+        }
+    }, [
+        screenKind,
+        confirm,
+        draft,
+        post,
+        hostId,
+        screenId,
+        enqueueSnackbar
+    ]);
+    const handleRemove = useCallback(async ()=>{
+        var _ref;
+        const accepted = await confirm({
+            title: 'Stop serving record pages?',
+            description: `Every page under /${(_ref = current == null ? void 0 : current.base) != null ? _ref : ''}/ stops answering. This page stays a ` + 'template, so it doesn’t answer at its own address either.',
+            confirmationText: 'Stop serving them',
+            confirmationButtonProps: {
+                color: 'error'
+            }
+        }).then(()=>true).catch(()=>false);
+        if (!accepted) return;
+        setBusy(true);
+        try {
+            await post('/api/hosts/record-pages', {
+                action: 'remove',
+                hostId,
+                screenId
+            });
+            enqueueSnackbar('Record pages removed', {
+                variant: 'success'
+            });
+        } catch (error) {
+            enqueueSnackbar(error.message, {
+                variant: 'error'
+            });
+            setBusy(false);
+            return;
+        }
+        // The page is left a template, which nobody can visit. Making it a page
+        // again is offered once, here, and checked against the plan's pages by
+        // the platform's convert route, whose refusal names the count.
+        const restore = await confirm({
+            title: 'Make this a normal page again?',
+            description: 'It counts toward your plan’s pages and, if it was published, answers at its ' + 'own address again right away. Placeholders like {{item.name}} show as plain ' + 'text until you edit them out.',
+            confirmationText: 'Make it a page',
+            cancellationText: 'Keep it hidden'
+        }).then(()=>true).catch(()=>false);
+        if (restore) {
+            try {
+                await post('/api/hosts/screens', {
+                    action: 'convert',
+                    hostId,
+                    id: screenId,
+                    kind: 'page'
+                });
+                enqueueSnackbar('This is a normal page again', {
+                    variant: 'success'
+                });
+            } catch (error) {
+                enqueueSnackbar(error.message, {
+                    variant: 'error'
+                });
+            }
+        }
+        setBusy(false);
+    }, [
+        confirm,
+        current == null ? void 0 : current.base,
+        post,
+        hostId,
+        screenId,
+        enqueueSnackbar
+    ]);
+    if (planReady && !checkEntitlement(org, 'dataStore')) {
+        return /*#__PURE__*/ _jsxs(Stack, {
+            spacing: 1,
+            children: [
+                /*#__PURE__*/ _jsx(Typography, {
+                    variant: "subtitle2",
+                    children: 'Record pages'
+                }),
+                /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    color: "text.secondary",
+                    children: 'Serve this page once per record of a dataset — a page for every service or ' + 'location. Record pages need a Starter plan or higher.'
+                })
+            ]
+        });
+    }
+    const ready = preview.status === 'ready' ? preview : null;
+    return /*#__PURE__*/ _jsxs(Stack, {
+        spacing: 1.5,
+        children: [
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "subtitle2",
+                children: 'Record pages'
+            }),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                children: current ? `This page is the template of every record of ${dataset ? datasetDisplayName(dataset) : 'its dataset'}, each at /${current.base}/ and its page address. Inside it, ` + '{{item.field}} fills in from the record.' : 'Serve this page once per record of a dataset, each at its own address — ' + '/services/roofing. Inside it, {{item.field}} fills in from the record, as in ' + 'a repeat.'
+            }),
+            /*#__PURE__*/ _jsx(TextField, {
+                select: true,
+                size: "small",
+                label: "Dataset",
+                value: draft.datasetId,
+                onChange: (event)=>setDraft(_extends({}, EMPTY_DRAFT, {
+                        base: draft.base,
+                        datasetId: event.target.value
+                    })),
+                helperText: "Only datasets shared with this site are listed",
+                children: datasets.map((one)=>/*#__PURE__*/ _jsx(MenuItem, {
+                        value: one.$id,
+                        children: datasetDisplayName(one) || one.$id
+                    }, one.$id))
+            }),
+            /*#__PURE__*/ _jsx(TextField, {
+                size: "small",
+                label: "Address",
+                value: draft.base,
+                onChange: (event)=>setDraft(_extends({}, draft, {
+                        base: event.target.value
+                    })),
+                error: Boolean(baseRefusal),
+                helperText: baseRefusal != null ? baseRefusal : draft.base ? `Records are served at /${draft.base.replace(/^\/+|\/+$/g, '')}/their-address` : 'One or more segments, like services or services/residential',
+                slotProps: {
+                    input: {
+                        startAdornment: /*#__PURE__*/ _jsx(InputAdornment, {
+                            position: "start",
+                            children: "/"
+                        })
+                    }
+                }
+            }),
+            model && addressFields.length ? /*#__PURE__*/ _jsx(TextField, {
+                select: true,
+                size: "small",
+                label: "Page address field",
+                value: draft.slugField,
+                onChange: (event)=>setDraft(_extends({}, draft, {
+                        slugField: event.target.value
+                    })),
+                helperText: "Each record's own segment of its address",
+                children: addressFields.map((fieldId)=>{
+                    var _ref;
+                    var _model_fields_fieldId;
+                    return /*#__PURE__*/ _jsx(MenuItem, {
+                        value: fieldId,
+                        children: (_ref = (_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.name) != null ? _ref : fieldId
+                    }, fieldId);
+                })
+            }) : model ? /*#__PURE__*/ _jsxs(Stack, {
+                spacing: 1,
+                children: [
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        children: 'This dataset has no Page address field yet. Make one from a text field: ' + 'every record gets an address made from its value (Roof Repair → ' + 'roof-repair), and new records get one as they are added. A record keeps its ' + 'address when it is renamed.'
+                    }),
+                    /*#__PURE__*/ _jsxs(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        sx: {
+                            alignItems: 'center'
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                select: true,
+                                size: "small",
+                                label: "Make addresses from",
+                                value: sourceField,
+                                onChange: (event)=>setSourceField(event.target.value),
+                                sx: {
+                                    flex: 1
+                                },
+                                children: textFields.map((fieldId)=>{
+                                    var _ref;
+                                    var _model_fields_fieldId;
+                                    return /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: fieldId,
+                                        children: (_ref = (_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.name) != null ? _ref : fieldId
+                                    }, fieldId);
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                variant: "outlined",
+                                onClick: handleAddAddresses,
+                                disabled: !sourceField || busy,
+                                children: 'Make addresses'
+                            })
+                        ]
+                    })
+                ]
+            }) : null,
+            model ? FIELD_PICKERS.map((picker)=>{
+                var _draft_picker_key;
+                return /*#__PURE__*/ _jsxs(TextField, {
+                    select: true,
+                    size: "small",
+                    label: picker.label,
+                    value: (_draft_picker_key = draft[picker.key]) != null ? _draft_picker_key : '',
+                    onChange: (event)=>setDraft(_extends({}, draft, {
+                            [picker.key]: event.target.value || undefined
+                        })),
+                    helperText: picker.helper,
+                    // The empty choice is a real one — "use the default" — so it is
+                    // shown rather than leaving the field looking blank.
+                    slotProps: {
+                        select: {
+                            displayEmpty: true
+                        },
+                        inputLabel: {
+                            shrink: true
+                        }
+                    },
+                    children: [
+                        /*#__PURE__*/ _jsx(MenuItem, {
+                            value: "",
+                            children: picker.empty
+                        }),
+                        model.order.map((fieldId)=>{
+                            var _ref;
+                            var _model_fields_fieldId;
+                            return /*#__PURE__*/ _jsx(MenuItem, {
+                                value: fieldId,
+                                children: (_ref = (_model_fields_fieldId = model.fields[fieldId]) == null ? void 0 : _model_fields_fieldId.name) != null ? _ref : fieldId
+                            }, fieldId);
+                        })
+                    ]
+                }, picker.key);
+            }) : null,
+            ready ? /*#__PURE__*/ _jsx(TextField, {
+                select: true,
+                size: "small",
+                label: "Preview with",
+                value: ready.selectedId,
+                onChange: (event)=>ready.select(event.target.value),
+                helperText: `The canvas draws this page for one of ${ready.choices.length}${ready.choices.length >= 100 ? '+' : ''} records`,
+                children: ready.choices.map((choice)=>/*#__PURE__*/ _jsx(MenuItem, {
+                        value: choice.id,
+                        children: choice.label
+                    }, choice.id))
+            }) : null,
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                children: [
+                    /*#__PURE__*/ _jsx(Button, {
+                        size: "small",
+                        variant: "outlined",
+                        onClick: handleSave,
+                        disabled: busy || !draft.datasetId || !draft.base || !draft.slugField || Boolean(baseRefusal),
+                        children: current ? 'Save record pages' : 'Serve record pages'
+                    }),
+                    current ? /*#__PURE__*/ _jsx(Button, {
+                        size: "small",
+                        color: "error",
+                        onClick: handleRemove,
+                        disabled: busy,
+                        children: 'Stop serving'
+                    }) : null
+                ]
+            })
+        ]
+    });
+}
+export default RecordTemplateSection;
+
+//# sourceMappingURL=record-template-section.component.js.map