@seamlet/astro 0.0.0-stage → 0.1.1

package/dist/chunk-EC42AIQC.js

@@ -0,0 +1,346 @@
+// src/schema/fields.ts
+function defineSchema(fields) {
+  return fields;
+}
+function text(options) {
+  return { kind: "text", ...options };
+}
+function number(options) {
+  return { kind: "number", ...options };
+}
+function date(options) {
+  return { kind: "date", ...options };
+}
+function image(options) {
+  return { kind: "image", ...options };
+}
+function link(options) {
+  return { kind: "link", ...options };
+}
+function group(options) {
+  return { kind: "group", ...options };
+}
+function collection(options) {
+  return { kind: "collection", ...options };
+}
+
+// src/schema/content.ts
+function defaultValue(field) {
+  switch (field.kind) {
+    case "text":
+      return "";
+    case "number":
+    case "date":
+    case "image":
+    case "link":
+      return null;
+    case "group":
+      return defaultContent(field.fields);
+    case "collection":
+      return [];
+  }
+}
+function defaultContent(fields) {
+  return Object.fromEntries(
+    Object.entries(fields).map(([name, field]) => [name, defaultValue(field)])
+  );
+}
+
+// src/schema/link-addresses.ts
+var PHONE_PREFIX = "tel:";
+var EMAIL_PREFIX = "mailto:";
+var WEB_PREFIX = "https://";
+var SITE_ORIGIN = "https://site.invalid";
+var FIRST_PRINTABLE_CODE = 32;
+var DELETE_CODE = 127;
+var BACKSLASH_CODE = 92;
+var WEB_ADDRESS = /^https?:\/\/[^\s/?#]+[^\s]*$/iu;
+var ANY_SCHEME = /^[a-z][a-z\d+.-]*:(?!\d)/iu;
+var PHONE_NUMBER = /^\+?[\d\s().-]*\d[\d\s().-]*$/u;
+var NOT_PHONE_DIGIT = /[^\d+]/gu;
+var EMAIL_ADDRESS = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+function linkTargetOf(href) {
+  const address = href;
+  const hasSpacesAround = address !== address.trim();
+  if (hasSpacesAround) {
+    return void 0;
+  }
+  if (isSitePath(address)) {
+    return { kind: "page", path: address };
+  }
+  if (WEB_ADDRESS.test(address)) {
+    return { kind: "web", url: address };
+  }
+  const phone = withoutPrefix(address, PHONE_PREFIX);
+  if (phone !== void 0 && PHONE_NUMBER.test(phone)) {
+    return { kind: "phone", number: phone };
+  }
+  const email = withoutPrefix(address, EMAIL_PREFIX);
+  if (email !== void 0 && EMAIL_ADDRESS.test(email)) {
+    return { kind: "email", address: email };
+  }
+  return void 0;
+}
+function hrefOf(target) {
+  switch (target.kind) {
+    case "page":
+      return target.path.trim();
+    case "web":
+      return webAddressOf(target.url.trim());
+    case "phone":
+      return `${PHONE_PREFIX}${target.number.replace(NOT_PHONE_DIGIT, "")}`;
+    case "email":
+      return `${EMAIL_PREFIX}${target.address.trim()}`;
+  }
+}
+function webAddressOf(typed) {
+  const hasScheme = ANY_SCHEME.test(typed);
+  return hasScheme || typed === "" ? typed : `${WEB_PREFIX}${typed}`;
+}
+function isSitePath(address) {
+  if (!address.startsWith("/") || hasAmbiguousCharacter(address)) {
+    return false;
+  }
+  return new URL(address, SITE_ORIGIN).origin === SITE_ORIGIN;
+}
+function hasAmbiguousCharacter(address) {
+  const codes = Array.from(
+    { length: address.length },
+    (_, index) => address.charCodeAt(index)
+  );
+  return codes.some(
+    (code) => code === BACKSLASH_CODE || code < FIRST_PRINTABLE_CODE || code === DELETE_CODE
+  );
+}
+function withoutPrefix(address, prefix) {
+  const hasPrefix = address.toLowerCase().startsWith(prefix);
+  return hasPrefix ? address.slice(prefix.length) : void 0;
+}
+
+// src/schema/parse-content.ts
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+var GRAPHEMES = new Intl.Segmenter("ru-RU", { granularity: "grapheme" });
+function formatFieldPath(path) {
+  return path.join(".");
+}
+function countCharacters(text2) {
+  return [...GRAPHEMES.segment(text2)].length;
+}
+function parseContent(schema, input) {
+  const parsed = parseFields(schema, input, []);
+  return { content: parsed.value, issues: parsed.issues };
+}
+function parseFields(fields, input, path) {
+  if (!isRecord(input)) {
+    return invalidType(defaultContent(fields), path);
+  }
+  const parsedFields = Object.entries(fields).map(([name, field]) => {
+    const fieldInput = Object.hasOwn(input, name) ? input[name] : void 0;
+    return [name, parseField(field, fieldInput, [...path, name])];
+  });
+  const content = Object.fromEntries(
+    parsedFields.map(([name, parsed]) => [name, parsed.value])
+  );
+  const issues = parsedFields.flatMap(([, parsed]) => parsed.issues);
+  return { value: content, issues };
+}
+function parseField(field, input, path) {
+  if (input === void 0) {
+    return valid(defaultValue(field));
+  }
+  switch (field.kind) {
+    case "text":
+      return parseText(field, input, path);
+    case "number":
+      return parseNumber(field, input, path);
+    case "date":
+      return parseDate(field, input, path);
+    case "image":
+      return parseImage(field, input, path);
+    case "link":
+      return parseLink(field, input, path);
+    case "group":
+      return parseFields(field.fields, input, path);
+    case "collection":
+      return parseCollection(field, input, path);
+  }
+}
+function parseText(field, input, path) {
+  if (typeof input !== "string") {
+    return invalidType(defaultValue(field), path);
+  }
+  const isTooLong = field.maxLength !== void 0 && countCharacters(input) > field.maxLength;
+  if (isTooLong) {
+    return {
+      value: input,
+      issues: [{ path, code: "too-long", maxLength: field.maxLength }]
+    };
+  }
+  return valid(input);
+}
+function parseNumber(field, input, path) {
+  if (input === null) {
+    return valid(null);
+  }
+  if (typeof input !== "number" || !Number.isFinite(input)) {
+    return invalidType(defaultValue(field), path);
+  }
+  if (field.min !== void 0 && input < field.min) {
+    return {
+      value: input,
+      issues: [{ path, code: "below-min", min: field.min }]
+    };
+  }
+  if (field.max !== void 0 && input > field.max) {
+    return {
+      value: input,
+      issues: [{ path, code: "above-max", max: field.max }]
+    };
+  }
+  return valid(input);
+}
+function parseDate(field, input, path) {
+  if (input === null) {
+    return valid(null);
+  }
+  if (typeof input !== "string") {
+    return invalidType(defaultValue(field), path);
+  }
+  if (!isCalendarDate(input)) {
+    return {
+      value: defaultValue(field),
+      issues: [{ path, code: "invalid-date" }]
+    };
+  }
+  return valid(input);
+}
+function parseImage(field, input, path) {
+  if (input === null) {
+    return valid(null);
+  }
+  const src = isRecord(input) ? input["src"] : void 0;
+  const alt = isRecord(input) ? input["alt"] : void 0;
+  if (typeof src !== "string" || typeof alt !== "string") {
+    return invalidType(defaultValue(field), path);
+  }
+  const image2 = { src, alt };
+  if (src.trim() === "") {
+    return { value: image2, issues: [{ path, code: "missing-image-src" }] };
+  }
+  return valid(image2);
+}
+function parseLink(field, input, path) {
+  if (input === null) {
+    return valid(null);
+  }
+  if (!isRecord(input)) {
+    return invalidType(defaultValue(field), path);
+  }
+  const { text: text2, href } = input;
+  if (typeof text2 !== "string" || typeof href !== "string") {
+    return invalidType(defaultValue(field), path);
+  }
+  const link2 = { text: text2, href };
+  if (href.trim() === "") {
+    return { value: link2, issues: [{ path, code: "missing-link-href" }] };
+  }
+  if (linkTargetOf(href) === void 0) {
+    return { value: link2, issues: [{ path, code: "unsupported-link-href" }] };
+  }
+  return valid(link2);
+}
+function parseCollection(field, input, path) {
+  if (!Array.isArray(input)) {
+    return invalidType(defaultValue(field), path);
+  }
+  const records = input;
+  const parsedRecords = records.map(
+    (record, index) => parseFields(field.item, record, [...path, index])
+  );
+  return {
+    value: parsedRecords.map((parsed) => parsed.value),
+    issues: parsedRecords.flatMap((parsed) => parsed.issues)
+  };
+}
+function isCalendarDate(value) {
+  if (!DATE_PATTERN.test(value)) {
+    return false;
+  }
+  const time = Date.parse(`${value}T00:00:00Z`);
+  return !Number.isNaN(time) && new Date(time).toISOString().startsWith(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function valid(value) {
+  return { value, issues: [] };
+}
+function invalidType(fallback, path) {
+  return { value: fallback, issues: [{ path, code: "invalid-type" }] };
+}
+
+// src/schema/field-markers.ts
+var FIELD_PATH_ATTRIBUTE = "data-cms-path";
+function editable() {
+  return (...path) => ({ [FIELD_PATH_ATTRIBUTE]: formatFieldPath(path) });
+}
+
+// src/schema/field-paths.ts
+var RECORD_INDEX_PATTERN = /^\d+$/u;
+function resolveFieldPath(schema, text2) {
+  return resolveInFields(schema, text2.split("."), []);
+}
+function resolveInFields(fields, segments, parentPath) {
+  const [name, ...rest] = segments;
+  const field = name !== void 0 && Object.hasOwn(fields, name) ? fields[name] : void 0;
+  if (name === void 0 || field === void 0) {
+    return void 0;
+  }
+  const path = [...parentPath, name];
+  if (rest.length === 0) {
+    return { kind: "field", path, field };
+  }
+  return resolveInsideField(field, rest, path);
+}
+function resolveInsideField(field, segments, path) {
+  if (field.kind === "group") {
+    return resolveInFields(field.fields, segments, path);
+  }
+  if (field.kind === "collection") {
+    return resolveInCollection(field, segments, path);
+  }
+  return void 0;
+}
+function resolveInCollection(collection2, segments, collectionPath) {
+  const [indexText, ...rest] = segments;
+  if (indexText === void 0 || !RECORD_INDEX_PATTERN.test(indexText)) {
+    return void 0;
+  }
+  const index = Number(indexText);
+  const recordPath = [...collectionPath, index];
+  if (rest.length === 0) {
+    return { kind: "record", path: recordPath, collection: collection2, index };
+  }
+  return resolveInFields(collection2.item, rest, recordPath);
+}
+
+export {
+  defineSchema,
+  text,
+  number,
+  date,
+  image,
+  link,
+  group,
+  collection,
+  defaultValue,
+  defaultContent,
+  linkTargetOf,
+  hrefOf,
+  formatFieldPath,
+  countCharacters,
+  parseContent,
+  FIELD_PATH_ATTRIBUTE,
+  editable,
+  resolveFieldPath
+};

package/dist/chunk-HRAL4X6W.js

@@ -0,0 +1,160 @@
+import {
+  formatFieldPath,
+  resolveFieldPath
+} from "./chunk-EC42AIQC.js";
+
+// src/bridge/editor-shortcuts.ts
+function shortcutOf(event) {
+  const hasCommandKey = event.metaKey || event.ctrlKey;
+  if (!hasCommandKey || event.altKey) {
+    return void 0;
+  }
+  switch (event.code) {
+    case "KeyS":
+      return "save";
+    case "KeyZ":
+      return event.shiftKey ? "redo" : "undo";
+    case "KeyY":
+      return "redo";
+    default:
+      return void 0;
+  }
+}
+
+// src/bridge/image-fields.ts
+function imageFieldAt(schema, path) {
+  const target = path === void 0 ? void 0 : resolveFieldPath(schema, path);
+  const isImage = target?.kind === "field" && target.field.kind === "image";
+  return isImage ? { path: target.path, field: target.field } : void 0;
+}
+
+// src/bridge/messages.ts
+var PROTOCOL_VERSION = 1;
+var EDITOR_KEYS = /* @__PURE__ */ new Set([
+  "save",
+  "undo",
+  "redo",
+  "escape"
+]);
+var TYPING_OUTCOMES = /* @__PURE__ */ new Set([
+  "kept",
+  "reverted"
+]);
+function readPageMessage(data) {
+  if (!isRecord(data)) return void 0;
+  return isPageMessage(data) ? data : void 0;
+}
+function readEditorMessage(data) {
+  if (!isRecord(data)) return void 0;
+  return isEditorMessage(data) ? data : void 0;
+}
+function isPageMessage(message) {
+  switch (message["type"]) {
+    case "ready":
+      return isNumber(message["protocol"]);
+    case "file-drag-end":
+    case "rendered":
+    case "render-failed":
+      return true;
+    case "layout":
+      return isLayout(message["layout"]);
+    case "hover":
+    case "file-drag":
+      return isOptional(message["path"], isString);
+    case "click":
+      return isOptional(message["target"], isClickTarget);
+    case "link-click":
+      return isString(message["href"]);
+    case "key":
+      return isString(message["key"]) && EDITOR_KEYS.has(message["key"]);
+    case "file-drop":
+      return isString(message["path"]) && message["file"] instanceof File;
+    case "typing-started":
+    case "typing-refused":
+      return isString(message["path"]);
+    case "typed":
+      return isString(message["path"]) && isString(message["text"]);
+    case "typing-ended":
+      return isString(message["path"]) && isString(message["outcome"]) && TYPING_OUTCOMES.has(message["outcome"]);
+    default:
+      return false;
+  }
+}
+function isEditorMessage(message) {
+  switch (message["type"]) {
+    case "connect":
+      return isRecord(message["schema"]);
+    case "render":
+      return isRecord(message["content"]);
+    case "start-typing":
+      return isString(message["path"]) && isString(message["text"]) && typeof message["isSingleLine"] === "boolean" && isPoint(message["point"]);
+    case "stop-typing":
+      return true;
+    case "scroll-to":
+      return isFieldPath(message["path"]);
+    default:
+      return false;
+  }
+}
+function isLayout(value) {
+  if (!isRecord(value)) return false;
+  const markers = value["markers"];
+  return Array.isArray(markers) && markers.every(isMarkerBox) && isViewport(value["viewport"]) && isOptional(value["link"], isLinkBox);
+}
+function isMarkerBox(value) {
+  return isRecord(value) && isString(value["path"]) && isBox(value["box"]);
+}
+function isLinkBox(value) {
+  return isRecord(value) && isString(value["href"]) && isBox(value["box"]);
+}
+function isClickTarget(value) {
+  return isRecord(value) && isString(value["path"]) && isPoint(value["point"]);
+}
+function isBox(value) {
+  return isRecord(value) && isNumber(value["top"]) && isNumber(value["left"]) && isNumber(value["width"]) && isNumber(value["height"]);
+}
+function isViewport(value) {
+  return isRecord(value) && isNumber(value["width"]) && isNumber(value["height"]);
+}
+function isPoint(value) {
+  return isRecord(value) && isNumber(value["x"]) && isNumber(value["y"]);
+}
+function isFieldPath(value) {
+  return Array.isArray(value) && value.every((segment) => isString(segment) || isNumber(segment));
+}
+function isOptional(value, isPresent) {
+  return value === void 0 || isPresent(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/bridge/file-drags.ts
+function carriesFiles(event) {
+  return event.dataTransfer?.types.includes("Files") === true;
+}
+
+// src/bridge/marked-paths.ts
+function closestMarkedPath(path, isMarked) {
+  for (let length = path.length; length > 0; length -= 1) {
+    const candidate = formatFieldPath(path.slice(0, length));
+    if (isMarked(candidate)) return candidate;
+  }
+  return void 0;
+}
+
+export {
+  shortcutOf,
+  imageFieldAt,
+  PROTOCOL_VERSION,
+  readPageMessage,
+  readEditorMessage,
+  carriesFiles,
+  closestMarkedPath
+};

package/dist/chunk-P2OQOZBC.js

@@ -0,0 +1,55 @@
+// src/preview-requests.ts
+var MAX_DRAFT_BYTES = 1024 * 1024;
+var BAD_REQUEST = 400;
+var PAYLOAD_TOO_LARGE = 413;
+var UNSUPPORTED_MEDIA_TYPE = 415;
+var UPLOADED_PHOTO = /^[A-Za-z0-9_-]+\.webp$/u;
+async function readDraft(request) {
+  const isJson = request.headers.get("Content-Type")?.startsWith("application/json") === true;
+  if (!isJson) return refused(UNSUPPORTED_MEDIA_TYPE);
+  const body = await readLimited(request);
+  if (body === void 0) return refused(PAYLOAD_TOO_LARGE);
+  try {
+    return { isRead: true, draft: JSON.parse(body) };
+  } catch {
+    return refused(BAD_REQUEST);
+  }
+}
+function isUploadedPhoto(fileName) {
+  return fileName !== void 0 && UPLOADED_PHOTO.test(fileName);
+}
+async function readLimited(request) {
+  if (request.body === null) return "";
+  const reader = request.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > MAX_DRAFT_BYTES) {
+      await reader.cancel();
+      return void 0;
+    }
+    chunks.push(value);
+  }
+  return new TextDecoder().decode(concatenated(chunks, size));
+}
+function concatenated(chunks, size) {
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function refused(status) {
+  return { isRead: false, response: new Response(null, { status }) };
+}
+
+export {
+  MAX_DRAFT_BYTES,
+  readDraft,
+  isUploadedPhoto
+};

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/client.js

@@ -0,0 +1,11 @@
+// src/client.ts
+import { cmsOrigin } from "virtual:seamlet/config";
+var PREVIEW_PATH = "/preview";
+var isFramed = window.parent !== window;
+var { pathname } = window.location;
+var isPreview = pathname === PREVIEW_PATH || pathname.startsWith(`${PREVIEW_PATH}/`);
+if (isFramed && isPreview) {
+  void import("./bridge.js").then(({ connectToEditor }) => {
+    connectToEditor({ editorOrigin: cmsOrigin });
+  });
+}

package/dist/content-DKVM1CUQ.d.ts

@@ -0,0 +1,90 @@
+interface TextField {
+    readonly kind: "text";
+    readonly label: string;
+    /** A textarea instead of a single line. */
+    readonly multiline?: boolean;
+    /** In characters as people see them (see countCharacters), not UTF-16 units. */
+    readonly maxLength?: number;
+}
+interface NumberField {
+    readonly kind: "number";
+    readonly label: string;
+    readonly min?: number;
+    readonly max?: number;
+}
+/** A calendar date without time, stored as `YYYY-MM-DD`. */
+interface DateField {
+    readonly kind: "date";
+    readonly label: string;
+}
+/** An image address with its alternative text. */
+interface ImageField {
+    readonly kind: "image";
+    readonly label: string;
+}
+/**
+ * A link: its text and where it leads (a page of the site, another site, a phone or an email).
+ * The site decides how it looks; a button «Записаться» stays a button.
+ */
+interface LinkField {
+    readonly kind: "link";
+    readonly label: string;
+}
+/** Named fields shown and stored together, for example the first screen of a page. */
+interface GroupField<F extends Fields = Fields> {
+    readonly kind: "group";
+    readonly label: string;
+    readonly fields: F;
+}
+/** A list of records of the same shape, for example the items of a menu. */
+interface CollectionField<F extends Fields = Fields> {
+    readonly kind: "collection";
+    readonly label: string;
+    readonly item: F;
+    /** The field of a record that names it in the editor: a text field, or a link by its text. */
+    readonly itemTitle?: keyof F & string;
+}
+type Field = TextField | NumberField | DateField | ImageField | LinkField | GroupField | CollectionField;
+type FieldKind = Field["kind"];
+/** Field names to fields; the order of the keys is the order of the form. */
+interface Fields {
+    readonly [name: string]: Field;
+}
+type FieldOptions<F extends Field> = Omit<F, "kind">;
+/** The root of a site's schema. Only checks the shape and keeps the literal types. */
+declare function defineSchema<F extends Fields>(fields: F): F;
+declare function text(options: FieldOptions<TextField>): TextField;
+declare function number(options: FieldOptions<NumberField>): NumberField;
+declare function date(options: FieldOptions<DateField>): DateField;
+declare function image(options: FieldOptions<ImageField>): ImageField;
+declare function link(options: FieldOptions<LinkField>): LinkField;
+declare function group<F extends Fields>(options: FieldOptions<GroupField<F>>): GroupField<F>;
+declare function collection<F extends Fields>(options: FieldOptions<CollectionField<F>>): CollectionField<F>;
+
+interface ImageValue {
+    readonly src: string;
+    readonly alt: string;
+}
+interface LinkValue {
+    readonly text: string;
+    /** A path of the site (`/menu`), a web address, `tel:` or `mailto:`; see linkTargetOf. */
+    readonly href: string;
+}
+/**
+ * The value of each field. A text can be empty (""), the other scalar fields can be unset (null):
+ * content is filled in by people, so a site must be ready for a missing price or date.
+ */
+type ValueOf<F extends Field> = F extends TextField ? string : F extends NumberField ? number | null : F extends DateField ? string | null : F extends ImageField ? ImageValue | null : F extends LinkField ? LinkValue | null : F extends GroupField<infer Group> ? ContentOf<Group> : F extends CollectionField<infer Item> ? readonly ContentOf<Item>[] : never;
+/** The content a schema describes: `ContentOf<typeof schema>` is the type a site renders. */
+type ContentOf<F extends Fields> = {
+    readonly [Name in keyof F]: ValueOf<F[Name]>;
+};
+/** Content of any schema, for code that works with every site, such as the editor and the store. */
+interface Content {
+    readonly [name: string]: FieldValue;
+}
+type FieldValue = string | number | null | ImageValue | LinkValue | Content | readonly Content[];
+declare function defaultValue(field: Field): FieldValue;
+declare function defaultContent(fields: Fields): Content;
+
+export { type ContentOf as C, type DateField as D, type Fields as F, type GroupField as G, type ImageField as I, type LinkValue as L, type NumberField as N, type TextField as T, type ValueOf as V, type ImageValue as a, type Field as b, type CollectionField as c, type Content as d, type FieldKind as e, type FieldValue as f, type LinkField as g, collection as h, date as i, defaultContent as j, defaultValue as k, defineSchema as l, group as m, image as n, link as o, number as p, text as t };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { AstroIntegration } from 'astro';
+
+interface SeamletOptions {
+    /** The address of the CMS, such as `https://cms.example.com`. */
+    readonly cms: string;
+    /** The module of the site, relative to the project: `defineSeamletSite(…)` as its default export. */
+    readonly site: string;
+}
+declare function seamlet(options: SeamletOptions): AstroIntegration;
+
+export { type SeamletOptions, seamlet as default };