@seamlet/astro 1.2.1 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.3.0
+
+- Requests: `requestForm({ id, title, fields })` with `requestText`, `requestLongText`, `requestPhone`, `requestEmail` and `requestChoice` declares a form visitors send the business requests with; `defineSeamletSite` takes them as `forms`, and the site's description tells the CMS about them. `RequestForm.astro` renders one, with a checkbox of consent of its own; it is posted to the CMS without a script, and sent in place with it.
+- `readRequestEntries(body)` reads a request's body into its words, and `readRequestValues(form, entries)` checks a request the same way in the browser and in the CMS, with issues by field (`required`, `too-long`, `invalid-phone`, `invalid-email`, `unknown-option`) and their texts (`REQUEST_ISSUE_TEXTS`).
+- The events `seamlet:request-send` (cancelable), `seamlet:request-sent` and `seamlet:request-failed` on the form let the site's code send a request its own way or follow it.
+
+A site with forms needs a CMS that reads descriptions of 1.3 (cms.seamlet.ru from its release that takes requests). Code with an exhaustive `switch` over `SiteDescriptionProblem` gets its new members to handle.
+
 ## 1.2.1
 
 - `site.staticPaths(content)` is what Astro's `GetStaticPaths` takes: a static site's `[...page]` route may write `satisfies GetStaticPaths` and read its props with `InferGetStaticPropsType`. `StaticPage` and `RenderedPage` became type aliases, and `staticPaths` returns a mutable array.

package/README.md

@@ -362,6 +362,71 @@ A field is edited where it is seen, so the editor opens what hides it when a per
 
 What was opened stays open while the page is rendered anew after every edit: a part is known again by its `id`, or else by the field marked on it, in it or around it.
 
+## Requests
+
+A visitor sends the business a request from the site: «Обратный звонок», «Рассчитать стоимость», «Бронь столика». The site declares its forms, gives them to `defineSeamletSite` and renders them; the CMS keeps every request a year, writes to the people who edit the site and passes it on where the site's developer says.
+
+```ts
+// src/forms.ts
+import {
+  requestChoice,
+  requestForm,
+  requestLongText,
+  requestPhone,
+  requestText,
+} from "@seamlet/astro/schema";
+
+export const estimateForm = requestForm({
+  id: "estimate",
+  title: "Рассчитать стоимость",
+  fields: {
+    name: requestText({ label: "Имя", required: true }),
+    phone: requestPhone({ label: "Телефон", required: true }),
+    size: requestChoice({ label: "Размер", options: ["6×4", "6×6"] }),
+    comment: requestLongText({ label: "Комментарий", maxLength: 1000 }),
+  },
+});
+```
+
+```ts
+// src/seamlet.ts
+export default defineSeamletSite({
+  schema,
+  initialContent,
+  pages,
+  forms: [estimateForm],
+});
+```
+
+```astro
+---
+import RequestForm from "@seamlet/astro/components/RequestForm.astro";
+import { estimateForm } from "../forms";
+---
+
+<RequestForm form={estimateForm} submitLabel="Рассчитать" />
+```
+
+The fields are `requestText` (a line), `requestLongText` (several lines), `requestPhone`, `requestEmail` and `requestChoice` (one of `options`); each may be `required`, and a text has a `maxLength` (200 for a line, 2000 for several by default). A field's name is a name such as `phone` or `preferredTime`. The form's `title` names its requests in the CMS and in the letters.
+
+`RequestForm.astro` renders plain elements with classes (`seamlet-form`, `seamlet-form-field`, `seamlet-form-issue`, `seamlet-form-consent`, `seamlet-form-policy`, `seamlet-form-submit`, `seamlet-form-sent`, `seamlet-form-failed`), which the site styles from around it: `.contacts :global(.seamlet-form-field)`. Its props are the `form`, the words of the button (`submitLabel`), what the visitor reads once the request is sent or could not be (`sentText`, `failedText`), the addresses of the texts of consent and of the policy (`consentHref`, `policyHref`, the CMS's pages of them by default) and `instance`, which tells apart two forms of the same id on one page.
+
+The visitor consents with a checkbox of its own, never checked beforehand, to the texts the business confirmed in the CMS: until then the CMS takes no requests of the site, and the form says it could not send. Without a script the form is posted to the CMS, which answers with a page of its own; with the package's script (on every page, loaded only where a form is) the visitor stays on the page. The script checks what was typed with the code the CMS checks it with (`readRequestValues`), says what to fix under each field and sends the request.
+
+The site's own code hears every step from events on the form element, which bubble:
+
+- `seamlet:request-send` (`REQUEST_SEND_EVENT`), before the request is sent, with `{ form, entries }`. Cancelable: after `event.preventDefault()` the package sends nothing, and the site sends the request its own way.
+- `seamlet:request-sent` (`REQUEST_SENT_EVENT`), once the CMS has kept it, with `{ form, entries, id }`: a goal of the site's analytics, its own message.
+- `seamlet:request-failed` (`REQUEST_FAILED_EVENT`), with `{ form, reason, issues }`; `reason` is `invalid`, `closed` (the business takes no requests yet), `too-many` or `unavailable`.
+
+```ts
+document.addEventListener(REQUEST_SENT_EVENT, (event) => {
+  ym(COUNTER, "reachGoal", event.detail.form);
+});
+```
+
+A site whose `Content-Security-Policy` sets `connect-src` or `form-action` lets the CMS's origin in both. A request the policy stops on its way is posted by the browser as a plain form.
+
 ## What the integration adds
 
 - `/preview` and `/preview/<page>`: the preview the CMS's editor frames, the pages of records too (at their address or at the record's id, a page the site does not show too). `GET` shows the published content; `POST` with the content as JSON shows that content without saving it, which is how the editor shows every edit at once. Only the CMS may frame it (`Content-Security-Policy: frame-ancestors`), and it is never indexed or cached; its refusals (an address of no page, a record a draft does not have, a draft that is not JSON or is over 1 MB) say the same.

package/components/RequestForm.astro

@@ -0,0 +1,192 @@
+---
+// A form of the site's requests as plain elements, which the site styles from around it
+// (`.contacts :global(.seamlet-form-field)`). Without a script it is a form posted to the CMS, and
+// the CMS answers with a page of its own; the package's script sends it in place. The checkbox of
+// consent stands apart from the fields and is never checked beforehand, as the law asks: the
+// visitor consents to the texts of the business, which the CMS shows at their addresses.
+import { cmsOrigin, siteId } from "virtual:seamlet/config";
+import {
+  legalPagePathOf,
+  maxLengthOf,
+  REQUEST_CONSENT_KEY,
+  REQUEST_FORM_KEY,
+  REQUEST_PAGE_KEY,
+  REQUEST_TRAP_KEY,
+  requestsPathOf,
+  type RequestField,
+  type RequestForm,
+} from "@seamlet/astro/schema";
+
+interface Props {
+  readonly form: RequestForm;
+  /** The words of the button. */
+  readonly submitLabel?: string;
+  /** What the visitor reads once the business has the request. */
+  readonly sentText?: string;
+  /** What the visitor reads when the request could not be sent. */
+  readonly failedText?: string;
+  /** Where the text of consent is: the CMS's page of it unless the site has its own. */
+  readonly consentHref?: string;
+  /** Where the business's policy is: the CMS's page of it unless the site has its own. */
+  readonly policyHref?: string;
+  /** Tells two forms of the same id on one page apart, in the ids of their elements. */
+  readonly instance?: string;
+  readonly class?: string;
+}
+
+const {
+  form,
+  submitLabel = "Отправить",
+  sentText = "Спасибо! Заявка отправлена, мы скоро свяжемся с вами.",
+  failedText = "Не получилось отправить заявку. Попробуйте ещё раз чуть позже.",
+  consentHref = new URL(legalPagePathOf(siteId, "consent"), cmsOrigin).href,
+  policyHref = new URL(legalPagePathOf(siteId, "privacy"), cmsOrigin).href,
+  instance = form.id,
+  class: className,
+} = Astro.props;
+
+const action = new URL(requestsPathOf(siteId), cmsOrigin).href;
+const fields = Object.entries(form.fields);
+const idOf = (name: string) => `seamlet-${instance}-${name}`;
+const issueIdOf = (name: string) => `${idOf(name)}-issue`;
+/** The page the form stands on, so the business knows where the request came from. */
+const page = Astro.url.pathname;
+/** A field typed on one line of an `<input>`. */
+type LineField = Extract<RequestField, { kind: "text" | "phone" | "email" }>;
+const INPUT_TYPES: Readonly<Record<LineField["kind"], string>> = {
+  text: "text",
+  phone: "tel",
+  email: "email",
+};
+/** What a phone's keyboard and a browser's memory of addresses offer for a field. */
+const AUTOCOMPLETE: Partial<Record<LineField["kind"], string>> = {
+  phone: "tel",
+  email: "email",
+};
+const isLineField = (field: RequestField): field is LineField =>
+  field.kind === "text" || field.kind === "phone" || field.kind === "email";
+---
+
+<form
+  class:list={["seamlet-form", className]}
+  method="post"
+  action={action}
+  data-seamlet-form={form.id}
+  data-seamlet-request-form={JSON.stringify(form)}
+>
+  <input type="hidden" name={REQUEST_FORM_KEY} value={form.id} />
+  <input type="hidden" name={REQUEST_PAGE_KEY} value={page} />
+  {fields.map(([name, field]) => (
+    <div class="seamlet-form-field" data-field={name}>
+      <label for={idOf(name)}>
+        {field.label}
+        {field.required === true && <span aria-hidden="true"> *</span>}
+      </label>
+      {field.kind === "longText" && (
+        <textarea
+          id={idOf(name)}
+          name={name}
+          rows="4"
+          required={field.required === true}
+          maxlength={maxLengthOf(field)}
+          aria-describedby={issueIdOf(name)}
+        />
+      )}
+      {field.kind === "choice" && (
+        <select
+          id={idOf(name)}
+          name={name}
+          required={field.required === true}
+          aria-describedby={issueIdOf(name)}
+        >
+          <option value="">Выберите</option>
+          {field.options.map((option) => (
+            <option value={option}>{option}</option>
+          ))}
+        </select>
+      )}
+      {isLineField(field) && (
+        <input
+          id={idOf(name)}
+          name={name}
+          type={INPUT_TYPES[field.kind]}
+          required={field.required === true}
+          maxlength={field.kind === "text" ? maxLengthOf(field) : undefined}
+          autocomplete={AUTOCOMPLETE[field.kind]}
+          aria-describedby={issueIdOf(name)}
+        />
+      )}
+      <p
+        class="seamlet-form-issue"
+        id={issueIdOf(name)}
+        data-seamlet-issue={name}
+        hidden
+      />
+    </div>
+  ))}
+  <div class="seamlet-form-trap" aria-hidden="true">
+    <label>
+      Это поле заполнять не нужно
+      <input
+        type="text"
+        name={REQUEST_TRAP_KEY}
+        tabindex="-1"
+        autocomplete="off"
+      />
+    </label>
+  </div>
+  <div class="seamlet-form-consent">
+    <input
+      id={idOf(REQUEST_CONSENT_KEY)}
+      type="checkbox"
+      name={REQUEST_CONSENT_KEY}
+      value="on"
+      required
+      aria-describedby={issueIdOf(REQUEST_CONSENT_KEY)}
+    />
+    <label for={idOf(REQUEST_CONSENT_KEY)}>
+      Даю{" "}
+      <a href={consentHref} target="_blank" rel="noopener">
+        согласие на обработку персональных данных
+      </a>
+    </label>
+    <p
+      class="seamlet-form-issue"
+      id={issueIdOf(REQUEST_CONSENT_KEY)}
+      data-seamlet-issue={REQUEST_CONSENT_KEY}
+      hidden
+    />
+  </div>
+  <p class="seamlet-form-policy">
+    <a href={policyHref} target="_blank" rel="noopener">
+      Политика обработки персональных данных
+    </a>
+  </p>
+  <button class="seamlet-form-submit" type="submit">
+    {submitLabel}
+  </button>
+  <p
+    class="seamlet-form-sent"
+    role="status"
+    tabindex="-1"
+    data-seamlet-sent
+    data-seamlet-text={sentText}
+  />
+  <p
+    class="seamlet-form-failed"
+    role="alert"
+    data-seamlet-failed
+    data-seamlet-text={failedText}
+  />
+</form>
+
+<style>
+  /* Out of sight and out of reach of the keyboard, yet a field a program fills. */
+  .seamlet-form-trap {
+    position: absolute;
+    left: -10000px;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+  }
+</style>

package/dist/bridge.js

@@ -18,7 +18,7 @@ import {
   shortcutOf,
   toggleList,
   toggleMark
-} from "./chunk-Y4R4YV5O.js";
+} from "./chunk-2GZZHXP5.js";
 import {
   FIELD_PATH_ATTRIBUTE,
   REVEALED_ATTRIBUTE,
@@ -28,7 +28,7 @@ import {
   readRichText,
   resolveFieldPath,
   safeHref
-} from "./chunk-UL2C2IB2.js";
+} from "./chunk-ENMUO442.js";
 
 // src/bridge/typed-fields.ts
 function typedKindAt(schema, path) {

package/dist/{chunk-Y4R4YV5O.js → chunk-2GZZHXP5.js}

@@ -6,7 +6,7 @@ import {
   readRichText,
   resolveFieldPath,
   safeHref
-} from "./chunk-UL2C2IB2.js";
+} from "./chunk-ENMUO442.js";
 
 // src/bridge/editor-shortcuts.ts
 function shortcutOf(event) {

package/dist/chunk-2IK7D2AA.js

@@ -0,0 +1,6 @@
+// src/request-form-markers.ts
+var REQUEST_FORM_SELECTOR = "form[data-seamlet-form]";
+
+export {
+  REQUEST_FORM_SELECTOR
+};

package/dist/{chunk-UL2C2IB2.js → chunk-ENMUO442.js}

@@ -1325,6 +1325,106 @@ function originOf(value) {
   return WEB_PROTOCOLS.has(url2.protocol) ? url2.origin : void 0;
 }
 
+// src/schema/request-forms.ts
+var DEFAULT_TEXT_LENGTH = 200;
+var DEFAULT_LONG_TEXT_LENGTH = 2e3;
+var MAX_REQUEST_FIELD_LENGTH = 5e3;
+var MAX_OPTIONS = 50;
+var MAX_FORM_ID_LENGTH = 40;
+var FORM_ID = /^[a-z][a-z0-9-]*$/u;
+var FIELD_NAME = /^[a-z][a-zA-Z0-9]*$/u;
+var LINE_BREAK = /[\r\n]/u;
+var REQUEST_FIELD_KINDS = [
+  "text",
+  "longText",
+  "phone",
+  "email",
+  "choice"
+];
+function requestForm(form) {
+  return form;
+}
+function requestText(options) {
+  return { kind: "text", ...options };
+}
+function requestLongText(options) {
+  return { kind: "longText", ...options };
+}
+function requestPhone(options) {
+  return { kind: "phone", ...options };
+}
+function requestEmail(options) {
+  return { kind: "email", ...options };
+}
+function requestChoice(options) {
+  return { kind: "choice", ...options };
+}
+function readRequestForm(input) {
+  if (!isJsonObject(input)) return invalidForm("not-a-form");
+  const { id, title, fields } = input;
+  if (!isFormId(id)) return invalidForm("invalid-id");
+  if (!isText(title)) return invalidForm("invalid-title");
+  if (!isJsonObject(fields)) return invalidForm("no-fields");
+  const entries = Object.entries(fields);
+  if (entries.length === 0) return invalidForm("no-fields");
+  const hasInvalidName = entries.some(([name]) => !FIELD_NAME.test(name));
+  if (hasInvalidName) return invalidForm("invalid-field-name");
+  const readFields2 = entries.map(
+    ([name, field]) => [name, readRequestField(field)]
+  );
+  const isEveryFieldRead = readFields2.every(([, field]) => field !== void 0);
+  if (!isEveryFieldRead) return invalidForm("invalid-field");
+  const form = { id, title, fields: Object.fromEntries(readFields2) };
+  return { status: "read", form };
+}
+function isFormId(value) {
+  return typeof value === "string" && value.length <= MAX_FORM_ID_LENGTH && FORM_ID.test(value);
+}
+function maxLengthOf(field) {
+  const fallback = field.kind === "text" ? DEFAULT_TEXT_LENGTH : DEFAULT_LONG_TEXT_LENGTH;
+  return field.maxLength ?? fallback;
+}
+function readRequestField(input) {
+  if (!isJsonObject(input)) return void 0;
+  const { kind, label, required } = input;
+  if (!isRequestFieldKind(kind) || !isText(label)) return void 0;
+  if (required !== void 0 && typeof required !== "boolean") {
+    return void 0;
+  }
+  const common = { label, ...required === void 0 ? {} : { required } };
+  switch (kind) {
+    case "text":
+    case "longText":
+      return withMaxLength(kind, common, input["maxLength"]);
+    case "phone":
+    case "email":
+      return { kind, ...common };
+    case "choice":
+      return withOptions2(common, input["options"]);
+  }
+}
+function withMaxLength(kind, common, maxLength) {
+  if (maxLength === void 0) return { kind, ...common };
+  const isSoundLength = Number.isInteger(maxLength) && typeof maxLength === "number" && maxLength > 0 && maxLength <= MAX_REQUEST_FIELD_LENGTH;
+  return isSoundLength ? { kind, ...common, maxLength } : void 0;
+}
+function withOptions2(common, options) {
+  if (!Array.isArray(options)) return void 0;
+  const values = options;
+  const texts = values.filter(isOptionText);
+  const isSoundList = texts.length === values.length && texts.length > 0 && texts.length <= MAX_OPTIONS && new Set(texts).size === texts.length;
+  return isSoundList ? { kind: "choice", ...common, options: texts } : void 0;
+}
+function isRequestFieldKind(value) {
+  return REQUEST_FIELD_KINDS.some((kind) => kind === value);
+}
+function invalidForm(reason) {
+  return { status: "invalid", reason };
+}
+function isOptionText(value) {
+  return isText(value) && value === value.trim() && !LINE_BREAK.test(value);
+}
+
 // src/schema/record-pages.ts
 var RECORD_PLACEHOLDER = "[record]";
 var RECORD_PAGE_PATH = new RegExp(
@@ -1407,16 +1507,18 @@ function checkSiteDescription(input) {
   const initial = parseContent(schema.fields, input["initialContent"]);
   const pages = checkPages(schema.fields, input["pages"]);
   const recordPages2 = checkRecordPages(schema.fields, input["recordPages"]);
+  const forms = checkForms(input["forms"]);
   const problems = [
     ...nameProblems,
     ...initialContentProblems(initial.issues),
     ...pages.problems,
     ...recordPages2.problems,
     ...placementProblems(pages.pages ?? [], recordPages2.pages ?? []),
-    ...addressProblems(schema.fields, initial.content, recordPages2.pages ?? [])
+    ...addressProblems(schema.fields, initial.content, recordPages2.pages ?? []),
+    ...forms.problems
   ];
   const isNamed = isSiteId(id) && isText(title);
-  const isWhole = pages.pages !== void 0 && recordPages2.pages !== void 0;
+  const isWhole = pages.pages !== void 0 && recordPages2.pages !== void 0 && forms.forms !== void 0;
   if (!isNamed || !isWhole || problems.length > 0) {
     return invalid(problems);
   }
@@ -1426,7 +1528,8 @@ function checkSiteDescription(input) {
     schema: schema.fields,
     initialContent: initial.content,
     pages: pages.pages,
-    ...recordPages2.pages.length === 0 ? {} : { recordPages: recordPages2.pages }
+    ...recordPages2.pages.length === 0 ? {} : { recordPages: recordPages2.pages },
+    ...forms.forms.length === 0 ? {} : { forms: forms.forms }
   };
   return { status: "read", description };
 }
@@ -1520,6 +1623,27 @@ function readRecordPage(schema, input) {
   const isSearchTexts = typeof searchTexts === "string" && isSearchTextsGroup(field.item, searchTexts);
   return isSearchTexts ? { path, collection: collection2, searchTexts } : "invalid-search-texts";
 }
+function checkForms(input) {
+  if (input === void 0) return { forms: [], problems: [] };
+  if (!Array.isArray(input)) {
+    return { forms: void 0, problems: [{ code: "invalid-forms" }] };
+  }
+  const entries = input;
+  const readings = entries.map((entry) => readRequestForm(entry));
+  const formProblems = readings.flatMap(
+    (reading, index) => reading.status === "invalid" ? [{ code: "invalid-form", index, reason: reading.reason }] : []
+  );
+  const forms = readings.flatMap(
+    (reading) => reading.status === "read" ? [reading.form] : []
+  );
+  const ids = forms.map((form) => form.id);
+  const repeated = ids.filter((id, index) => ids.indexOf(id) !== index);
+  const repeatProblems = [...new Set(repeated)].map(
+    (id) => ({ code: "repeated-form-id", id })
+  );
+  const problems = [...formProblems, ...repeatProblems];
+  return { forms: problems.length === 0 ? forms : void 0, problems };
+}
 function placementProblems(pages, recordPages2) {
   const misplaced = pages.filter(
     (page) => recordPageAt(recordPages2, page.path) !== void 0
@@ -1555,6 +1679,110 @@ function invalid(problems) {
   return { status: "invalid", problems };
 }
 
+// src/schema/request-values.ts
+var REQUEST_FORM_KEY = "seamlet-form";
+var REQUEST_PAGE_KEY = "seamlet-page";
+var REQUEST_CONSENT_KEY = "seamlet-consent";
+var REQUEST_TRAP_KEY = "seamlet-check";
+var CHECKED_VALUES = /* @__PURE__ */ new Set(["on", "true"]);
+var MAX_PAGE_LENGTH = 300;
+var PAGE_PATH2 = /^\/(?![/\\])[^\s\\]*$/u;
+var PHONE_SEPARATORS = /[\s().-]/gu;
+var PHONE_DIGITS = /^\+?\d{5,15}$/u;
+var EMAIL_ADDRESS2 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+var MAX_EMAIL_LENGTH = 254;
+var LINE_BREAKS = /\r\n?/gu;
+var ANY_LINE_BREAK = /[\r\n]+/gu;
+var REQUEST_ISSUE_TEXTS = {
+  required: "\u0417\u0430\u043F\u043E\u043B\u043D\u0438\u0442\u0435 \u044D\u0442\u043E \u043F\u043E\u043B\u0435",
+  "too-long": "\u0417\u0434\u0435\u0441\u044C \u0441\u043B\u0438\u0448\u043A\u043E\u043C \u0434\u043B\u0438\u043D\u043D\u044B\u0439 \u0442\u0435\u043A\u0441\u0442",
+  "invalid-phone": "\u041F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 \u043D\u043E\u043C\u0435\u0440 \u0442\u0435\u043B\u0435\u0444\u043E\u043D\u0430",
+  "invalid-email": "\u041F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 \u0430\u0434\u0440\u0435\u0441 \u043F\u043E\u0447\u0442\u044B",
+  "unknown-option": "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u043E\u0434\u0438\u043D \u0438\u0437 \u0432\u0430\u0440\u0438\u0430\u043D\u0442\u043E\u0432"
+};
+var CONSENT_REQUIRED_TEXT = "\u041E\u0442\u043C\u0435\u0442\u044C\u0442\u0435 \u0441\u043E\u0433\u043B\u0430\u0441\u0438\u0435 \u043D\u0430 \u043E\u0431\u0440\u0430\u0431\u043E\u0442\u043A\u0443 \u043F\u0435\u0440\u0441\u043E\u043D\u0430\u043B\u044C\u043D\u044B\u0445 \u0434\u0430\u043D\u043D\u044B\u0445";
+function readRequestValues(form, entries) {
+  const readings = Object.entries(form.fields).map(
+    ([name, field]) => readValue(name, field, entryOf(entries, name))
+  );
+  const issues = readings.filter(isIssue);
+  if (issues.length > 0) return { status: "invalid", issues };
+  const values = readings.filter(isFilledValue);
+  return { status: "read", values };
+}
+function readRequestEntries(input) {
+  if (!isJsonObject(input)) return {};
+  const pairs = Object.entries(input).filter(
+    (pair) => typeof pair[1] === "string"
+  );
+  return Object.fromEntries(pairs);
+}
+function isConsentGiven(entries) {
+  return CHECKED_VALUES.has(entryOf(entries, REQUEST_CONSENT_KEY));
+}
+function isTrapFilled(entries) {
+  return entryOf(entries, REQUEST_TRAP_KEY).trim() !== "";
+}
+function requestPageOf(entries) {
+  const page = entryOf(entries, REQUEST_PAGE_KEY);
+  const isPage = page.length <= MAX_PAGE_LENGTH && PAGE_PATH2.test(page);
+  return isPage ? page : "/";
+}
+function isPhoneNumber(typed) {
+  return PHONE_DIGITS.test(typed.replaceAll(PHONE_SEPARATORS, ""));
+}
+function isEmailAddress(typed) {
+  return typed.length <= MAX_EMAIL_LENGTH && EMAIL_ADDRESS2.test(typed);
+}
+function entryOf(entries, name) {
+  const entry = Object.hasOwn(entries, name) ? entries[name] : "";
+  return typeof entry === "string" ? entry : "";
+}
+function readValue(name, field, typed) {
+  const words = wordsOf(field, typed);
+  if (words === "") {
+    return field.required === true ? { field: name, code: "required" } : { field: name, label: field.label, value: "" };
+  }
+  const code = issueOf(field, words);
+  return code === void 0 ? { field: name, label: field.label, value: words } : { field: name, code };
+}
+function wordsOf(field, typed) {
+  const trimmed = typed.trim();
+  return field.kind === "longText" ? trimmed.replaceAll(LINE_BREAKS, "\n") : trimmed.replaceAll(ANY_LINE_BREAK, " ");
+}
+function issueOf(field, words) {
+  switch (field.kind) {
+    case "text":
+    case "longText":
+      return countCharacters(words) > maxLengthOf(field) ? "too-long" : void 0;
+    case "phone":
+      return isPhoneNumber(words) ? void 0 : "invalid-phone";
+    case "email":
+      return isEmailAddress(words) ? void 0 : "invalid-email";
+    case "choice":
+      return field.options.includes(words) ? void 0 : "unknown-option";
+  }
+}
+function isIssue(reading) {
+  return "code" in reading;
+}
+function isFilledValue(reading) {
+  return "value" in reading && reading.value !== "";
+}
+
+// src/schema/request-addresses.ts
+function requestsPathOf(siteId) {
+  return `/api/sites/${siteId}/requests`;
+}
+function legalPagePathOf(siteId, document) {
+  return `/legal/${siteId}/${document}`;
+}
+
+// src/schema/request-events.ts
+var REQUEST_SEND_EVENT = "seamlet:request-send";
+var REQUEST_SENT_EVENT = "seamlet:request-sent";
+var REQUEST_FAILED_EVENT = "seamlet:request-failed";
+
 export {
   defineSchema,
   text,
@@ -1618,6 +1846,18 @@ export {
   SITE_CONFIG_FILE,
   isSiteId,
   readSiteConfig,
+  DEFAULT_TEXT_LENGTH,
+  DEFAULT_LONG_TEXT_LENGTH,
+  MAX_REQUEST_FIELD_LENGTH,
+  requestForm,
+  requestText,
+  requestLongText,
+  requestPhone,
+  requestEmail,
+  requestChoice,
+  readRequestForm,
+  isFormId,
+  maxLengthOf,
   RECORD_PLACEHOLDER,
   PAGE_PATH_SEPARATOR,
   recordPages,
@@ -1630,5 +1870,23 @@ export {
   HOME_PAGE_PATH,
   readSiteDescription,
   checkSiteDescription,
-  isSearchTextsGroup
+  isSearchTextsGroup,
+  REQUEST_FORM_KEY,
+  REQUEST_PAGE_KEY,
+  REQUEST_CONSENT_KEY,
+  REQUEST_TRAP_KEY,
+  REQUEST_ISSUE_TEXTS,
+  CONSENT_REQUIRED_TEXT,
+  readRequestValues,
+  readRequestEntries,
+  isConsentGiven,
+  isTrapFilled,
+  requestPageOf,
+  isPhoneNumber,
+  isEmailAddress,
+  requestsPathOf,
+  legalPagePathOf,
+  REQUEST_SEND_EVENT,
+  REQUEST_SENT_EVENT,
+  REQUEST_FAILED_EVENT
 };

package/dist/{chunk-OCA2WYK3.js → chunk-MFD4TJPV.js}

@@ -1,6 +1,6 @@
 import {
   pagePathOf
-} from "./chunk-HFPZVDST.js";
+} from "./chunk-VQKAWFCQ.js";
 import {
   FIELD_PATH_SEPARATOR,
   collectionAt,
@@ -9,7 +9,7 @@ import {
   newRecord,
   recordAt,
   recordPageAt
-} from "./chunk-UL2C2IB2.js";
+} from "./chunk-ENMUO442.js";
 
 // src/preview-requests.ts
 var MAX_DRAFT_BYTES = 1024 * 1024;

package/dist/{chunk-HFPZVDST.js → chunk-VQKAWFCQ.js}

@@ -6,7 +6,7 @@ import {
   recordAt,
   recordPageAt,
   recordPagePath
-} from "./chunk-UL2C2IB2.js";
+} from "./chunk-ENMUO442.js";
 
 // src/site-pages.ts
 function pagePathOf(rest) {

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
   SITE_CONFIG_FILE,
   isSiteId,
   readSiteConfig
-} from "./chunk-UL2C2IB2.js";
+} from "./chunk-ENMUO442.js";
 
 // src/cli.ts
 import process from "process";