@shelamkoff/rector 1.0.0

package/dist/shared/blockDataNormalizers.js

@@ -0,0 +1,235 @@
+// @ts-check
+import { normalizeCarouselData } from './carouselData.js'
+import {
+  COLUMN_LAYOUT_SIZES,
+  GALLERY_LAYOUTS,
+  LINK_PREVIEW_TEMPLATES,
+} from './blockDataValidators.js'
+import { normalizePollData } from './pollData.js'
+import { sanitizeUrl } from './sanitize/sanitizeUrl.js'
+import {
+  normalizeHeadingLevel,
+  normalizeTextAlign,
+  normalizeTextValue,
+} from './textFormat.js'
+
+const ATTACH_VARIANTS = new Set(['a', 'b', 'f', 'g'])
+const GALLERY_BOOLEAN_OPTIONS = [
+  'loop', 'zoom', 'navigation', 'captions', 'thumbnails', 'fullscreen',
+]
+
+/** @param {unknown} value @returns {Record<string, unknown>} */
+function record(value) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? /** @type {Record<string, unknown>} */ (value)
+    : {}
+}
+
+/** @param {unknown} value @param {'link' | 'external' | 'media' | 'download'} policy */
+function url(value, policy) {
+  return sanitizeUrl(normalizeTextValue(value), { policy, fallback: '' })
+}
+
+/** @param {unknown} value */
+function positiveNumber(value) {
+  return Number.isFinite(value) && Number(value) > 0 ? Number(value) : undefined
+}
+
+/** @param {unknown} value */
+function nonNegativeNumber(value) {
+  return Number.isFinite(value) && Number(value) >= 0 ? Number(value) : 0
+}
+
+/** @param {unknown} value */
+function stringProperties(value) {
+  /** @type {Record<string, string>} */
+  const result = {}
+  for (const [key, item] of Object.entries(record(value))) {
+    if (typeof item === 'string') result[key] = item
+  }
+  return result
+}
+
+/**
+ * Convert malformed built-in block data into a safe render-only value.
+ *
+ * The `preserve` validation policy reports invalid data instead of rejecting
+ * the document. Renderers therefore need a deterministic boundary that cannot
+ * throw on arrays, objects, missing fields, or unsafe URLs. This function
+ * never mutates the caller's document and is used only after strict validation
+ * of the corresponding built-in block has failed.
+ *
+ * @param {string} type
+ * @param {unknown} input
+ * @returns {Record<string, unknown>}
+ */
+export function normalizeKnownBlockData(type, input) {
+  const source = record(input)
+  let sequence = 0
+  const createId = () => `preserved-${type}-${++sequence}`
+
+  switch (type) {
+    case 'paragraph':
+      return { text: normalizeTextValue(source.text), align: normalizeTextAlign(source.align) }
+    case 'heading':
+      return {
+        text: normalizeTextValue(source.text),
+        level: normalizeHeadingLevel(source.level),
+        align: normalizeTextAlign(source.align),
+      }
+    case 'list':
+      return {
+        style: source.style === 'ordered' ? 'ordered' : 'unordered',
+        items: (Array.isArray(source.items) ? source.items : []).map(normalizeTextValue),
+      }
+    case 'quote':
+      return { text: normalizeTextValue(source.text), caption: normalizeTextValue(source.caption) }
+    case 'code':
+      return { code: normalizeTextValue(source.code), language: normalizeTextValue(source.language) }
+    case 'delimiter':
+      return {}
+    case 'warning':
+      return { title: normalizeTextValue(source.title), message: normalizeTextValue(source.message) }
+    case 'raw':
+      return { html: normalizeTextValue(source.html) }
+    case 'toggle':
+      return {
+        title: normalizeTextValue(source.title),
+        content: normalizeTextValue(source.content),
+        open: source.open === true,
+      }
+    case 'spoiler':
+      return { label: normalizeTextValue(source.label), content: normalizeTextValue(source.content) }
+    case 'table': {
+      const rows = (Array.isArray(source.content) ? source.content : [])
+        .filter(Array.isArray)
+        .map(row => row.map(normalizeTextValue))
+      const width = rows.reduce((maximum, row) => Math.max(maximum, row.length), 0)
+      return {
+        withHeadings: source.withHeadings === true,
+        content: rows.map(row => Array.from({ length: width }, (_, index) => row[index] ?? '')),
+      }
+    }
+    case 'columns': {
+      const layout = typeof source.layout === 'string' && COLUMN_LAYOUT_SIZES[source.layout]
+        ? source.layout
+        : '1-1'
+      const columns = Array.isArray(source.columns) ? source.columns : []
+      return {
+        layout,
+        columns: Array.from({ length: COLUMN_LAYOUT_SIZES[layout] }, (_, index) => ({
+          content: normalizeTextValue(record(columns[index]).content),
+        })),
+      }
+    }
+    case 'checklist':
+      return {
+        items: (Array.isArray(source.items) ? source.items : []).map(item => {
+          const value = record(item)
+          return { text: normalizeTextValue(value.text), checked: value.checked === true }
+        }),
+      }
+    case 'gallery': {
+      const optionsSource = record(source.options)
+      /** @type {Record<string, boolean | number>} */
+      const options = {}
+      for (const key of GALLERY_BOOLEAN_OPTIONS) options[key] = optionsSource[key] === true
+      const autoplayInterval = positiveNumber(optionsSource.autoplayInterval)
+      if (autoplayInterval) options.autoplayInterval = autoplayInterval
+      return {
+        images: (Array.isArray(source.images) ? source.images : []).flatMap(item => {
+          const image = record(item)
+          const safeUrl = url(image.url, 'media')
+          return safeUrl ? [{ url: safeUrl, caption: normalizeTextValue(image.caption) }] : []
+        }),
+        layout: typeof source.layout === 'string' && GALLERY_LAYOUTS.includes(source.layout)
+          ? source.layout
+          : 'auto',
+        styles: stringProperties(source.styles),
+        options,
+      }
+    }
+    case 'embed':
+      return {
+        service: source.service === 'vimeo' ? 'vimeo' : 'youtube',
+        videoId: normalizeTextValue(source.videoId),
+        caption: normalizeTextValue(source.caption),
+        cover: url(source.cover, 'media'),
+        title: normalizeTextValue(source.title),
+        duration: normalizeTextValue(source.duration),
+      }
+    case 'linkPreview':
+      return {
+        url: url(source.url, 'external'),
+        title: normalizeTextValue(source.title),
+        description: normalizeTextValue(source.description),
+        image: url(source.image, 'media'),
+        favicon: url(source.favicon, 'media'),
+        domain: normalizeTextValue(source.domain),
+        template: typeof source.template === 'string' && LINK_PREVIEW_TEMPLATES.includes(source.template)
+          ? source.template
+          : 'notion',
+      }
+    case 'image': {
+      const file = record(source.file)
+      /** @type {Record<string, string | number>} */
+      const normalizedFile = { url: url(file.url, 'media') }
+      const width = positiveNumber(file.width)
+      const height = positiveNumber(file.height)
+      if (width) normalizedFile.width = width
+      if (height) normalizedFile.height = height
+      return {
+        file: normalizedFile,
+        caption: normalizeTextValue(source.caption),
+        withBorder: source.withBorder === true,
+        expanded: source.expanded === true,
+        withBackground: source.withBackground === true,
+        styles: stringProperties(source.styles),
+      }
+    }
+    case 'attaches': {
+      const candidates = Array.isArray(source.files)
+        ? source.files
+        : (Object.keys(record(source.file)).length ? [source.file] : [])
+      return {
+        files: candidates.flatMap(candidate => {
+          const file = record(candidate)
+          const safeUrl = url(file.url, 'download')
+          if (!safeUrl) return []
+          return [{
+            url: safeUrl,
+            name: normalizeTextValue(file.name),
+            extension: normalizeTextValue(file.extension),
+            size: nonNegativeNumber(file.size),
+          }]
+        }),
+        variant: typeof source.variant === 'string' && ATTACH_VARIANTS.has(source.variant)
+          ? source.variant
+          : 'f',
+      }
+    }
+    case 'person':
+      return {
+        persons: (Array.isArray(source.persons) ? source.persons : []).map(item => {
+          const person = record(item)
+          return {
+            avatar: url(person.avatar, 'media'),
+            name: normalizeTextValue(person.name),
+            role: normalizeTextValue(person.role),
+            bio: normalizeTextValue(person.bio),
+            links: (Array.isArray(person.links) ? person.links : []).flatMap(item => {
+              const link = record(item)
+              const safeUrl = url(link.url, 'link')
+              return safeUrl ? [{ type: normalizeTextValue(link.type), url: safeUrl }] : []
+            }),
+          }
+        }),
+      }
+    case 'carousel':
+      return normalizeCarouselData(source, createId)
+    case 'poll':
+      return normalizePollData(source, createId)
+    default:
+      return source
+  }
+}

package/dist/shared/blockDataValidators.d.ts

@@ -0,0 +1,81 @@
+/** @param {unknown} data */
+export function validateParagraphData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateHeadingData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateListData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateQuoteData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateCodeData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateDelimiterData(data: unknown): data is Record<string, unknown>;
+/** @param {unknown} data */
+export function validateWarningData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateRawData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateToggleData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateSpoilerData(data: unknown): boolean;
+/**
+ * Strict URL validation deliberately requires the stored value to already be
+ * canonical. Preserve mode may still normalize a value at the DOM boundary.
+ * @param {unknown} value
+ * @param {'link' | 'external' | 'media' | 'download'} policy
+ * @param {boolean} [optional]
+ */
+export function isCanonicalUrl(value: unknown, policy: "link" | "external" | "media" | "download", optional?: boolean): boolean;
+/** @param {unknown} data */
+export function validateTableData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateColumnsData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateChecklistData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateGalleryData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateEmbedData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateLinkPreviewData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateImageData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validateAttachesData(data: unknown): boolean;
+/** @param {unknown} data */
+export function validatePersonData(data: unknown): boolean;
+/** @param {string} type @param {unknown} data */
+export function validateKnownBlockData(type: string, data: unknown): any;
+export const COLUMN_LAYOUT_SIZES: Readonly<{
+    '1-1': 2;
+    '1-2': 2;
+    '2-1': 2;
+    '1-1-1': 3;
+}>;
+export const GALLERY_LAYOUTS: readonly string[];
+export const LINK_PREVIEW_TEMPLATES: readonly string[];
+export const BLOCK_DATA_VALIDATORS: Readonly<{
+    attaches: typeof validateAttachesData;
+    carousel: typeof validateCarouselData;
+    checklist: typeof validateChecklistData;
+    code: typeof validateCodeData;
+    columns: typeof validateColumnsData;
+    delimiter: typeof validateDelimiterData;
+    embed: typeof validateEmbedData;
+    gallery: typeof validateGalleryData;
+    heading: typeof validateHeadingData;
+    image: typeof validateImageData;
+    linkPreview: typeof validateLinkPreviewData;
+    list: typeof validateListData;
+    paragraph: typeof validateParagraphData;
+    person: typeof validatePersonData;
+    poll: typeof validatePollData;
+    quote: typeof validateQuoteData;
+    raw: typeof validateRawData;
+    spoiler: typeof validateSpoilerData;
+    table: typeof validateTableData;
+    toggle: typeof validateToggleData;
+    warning: typeof validateWarningData;
+}>;
+import { validateCarouselData } from './carouselData.js';
+import { validatePollData } from './pollData.js';

package/dist/shared/blockDataValidators.js

@@ -0,0 +1,313 @@
+import { sanitizeUrl } from './sanitize/sanitizeUrl.js'
+import { validatePollData } from './pollData.js'
+import { validateCarouselData } from './carouselData.js'
+import { isTextAlign } from './textFormat.js'
+
+export const COLUMN_LAYOUT_SIZES = Object.freeze({
+  '1-1': 2,
+  '1-2': 2,
+  '2-1': 2,
+  '1-1-1': 3,
+})
+
+export const GALLERY_LAYOUTS = Object.freeze([
+  'auto', '1', '2', '3a', '3b', '3c', '4a', '4b', '4c',
+  '5a', '5b', '5c', '6a', '6b', '6c', 'triptych', 'masonry',
+  'poly-5', 'poly-3arch', 'poly-5flat', 'poly-3steps',
+])
+
+export const LINK_PREVIEW_TEMPLATES = Object.freeze([
+  'horizontal', 'compact', 'large-top', 'minimal', 'twitter', 'notion', 'split',
+])
+
+const ATTACH_VARIANTS = new Set(['a', 'b', 'f', 'g'])
+const GALLERY_BOOLEAN_OPTIONS = [
+  'loop', 'zoom', 'navigation', 'captions', 'thumbnails', 'fullscreen',
+]
+const OPTIONAL_LINK_PREVIEW_STRINGS = [
+  'title', 'description', 'image', 'favicon', 'domain',
+]
+const OPTIONAL_EMBED_STRINGS = ['caption', 'cover', 'title', 'duration']
+
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function isRecord(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+/** @param {Record<string, unknown>} data @param {string[]} keys */
+function hasOptionalStrings(data, keys) {
+  return keys.every(key => data[key] === undefined || typeof data[key] === 'string')
+}
+
+/** @param {unknown} value */
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+/** @param {unknown} value */
+function isOptionalTextAlign(value) {
+  return value === undefined || isTextAlign(value)
+}
+
+/** @param {unknown} data */
+export function validateParagraphData(data) {
+  return isRecord(data)
+    && isNonEmptyString(data.text)
+    && isOptionalTextAlign(data.align)
+}
+
+/** @param {unknown} data */
+export function validateHeadingData(data) {
+  return isRecord(data)
+    && isNonEmptyString(data.text)
+    && Number.isInteger(data.level)
+    && Number(data.level) >= 2
+    && Number(data.level) <= 6
+    && isOptionalTextAlign(data.align)
+}
+
+/** @param {unknown} data */
+export function validateListData(data) {
+  return isRecord(data)
+    && (data.style === 'ordered' || data.style === 'unordered')
+    && Array.isArray(data.items)
+    && data.items.length > 0
+    && data.items.every(item => typeof item === 'string')
+    && data.items.some(isNonEmptyString)
+}
+
+/** @param {unknown} data */
+export function validateQuoteData(data) {
+  return isRecord(data)
+    && isNonEmptyString(data.text)
+    && typeof data.caption === 'string'
+}
+
+/** @param {unknown} data */
+export function validateCodeData(data) {
+  return isRecord(data)
+    && isNonEmptyString(data.code)
+    && (data.language === undefined || typeof data.language === 'string')
+}
+
+/** @param {unknown} data */
+export function validateDelimiterData(data) {
+  return isRecord(data)
+}
+
+/** @param {unknown} data */
+export function validateWarningData(data) {
+  return isRecord(data)
+    && typeof data.title === 'string'
+    && typeof data.message === 'string'
+    && (isNonEmptyString(data.title) || isNonEmptyString(data.message))
+}
+
+/** @param {unknown} data */
+export function validateRawData(data) {
+  return isRecord(data) && isNonEmptyString(data.html)
+}
+
+/** @param {unknown} data */
+export function validateToggleData(data) {
+  return isRecord(data)
+    && typeof data.title === 'string'
+    && typeof data.content === 'string'
+    && (data.open === undefined || typeof data.open === 'boolean')
+    && (isNonEmptyString(data.title) || isNonEmptyString(data.content))
+}
+
+/** @param {unknown} data */
+export function validateSpoilerData(data) {
+  return isRecord(data)
+    && typeof data.label === 'string'
+    && isNonEmptyString(data.content)
+}
+
+/**
+ * Strict URL validation deliberately requires the stored value to already be
+ * canonical. Preserve mode may still normalize a value at the DOM boundary.
+ * @param {unknown} value
+ * @param {'link' | 'external' | 'media' | 'download'} policy
+ * @param {boolean} [optional]
+ */
+export function isCanonicalUrl(value, policy, optional = false) {
+  if (optional && (value === undefined || value === '')) return true
+  if (typeof value !== 'string' || value.length === 0) return false
+  return sanitizeUrl(value, { policy, fallback: '' }) === value
+}
+
+/** @param {unknown} data */
+export function validateTableData(data) {
+  if (!isRecord(data)) return false
+  const value = /** @type {Record<string, unknown>} */ (data)
+  const rows = value.content
+  if (!Array.isArray(rows) || rows.length === 0) return false
+  if (value.withHeadings !== undefined && typeof value.withHeadings !== 'boolean') return false
+  const width = Array.isArray(rows[0]) ? rows[0].length : 0
+  return width > 0 && rows.every(row => (
+    Array.isArray(row)
+    && row.length === width
+    && row.every(cell => typeof cell === 'string')
+  ))
+}
+
+/** @param {unknown} data */
+export function validateColumnsData(data) {
+  if (!isRecord(data)) return false
+  const value = /** @type {Record<string, unknown>} */ (data)
+  if (typeof value.layout !== 'string') return false
+  const size = COLUMN_LAYOUT_SIZES[value.layout]
+  return Number.isInteger(size)
+    && Array.isArray(value.columns)
+    && value.columns.length === size
+    && value.columns.every(column => isRecord(column) && typeof column.content === 'string')
+}
+
+/** @param {unknown} data */
+export function validateChecklistData(data) {
+  if (!isRecord(data)) return false
+  const items = /** @type {Record<string, unknown>} */ (data).items
+  return Array.isArray(items) && items.length > 0 && items.every(item => (
+    isRecord(item)
+    && typeof item.text === 'string'
+    && typeof item.checked === 'boolean'
+  ))
+}
+
+/** @param {unknown} data */
+export function validateGalleryData(data) {
+  if (!isRecord(data)) return false
+  const value = /** @type {Record<string, unknown>} */ (data)
+  if (!Array.isArray(value.images) || value.images.length === 0) return false
+  if (!value.images.every(image => (
+    isRecord(image)
+    && isCanonicalUrl(image.url, 'media')
+    && (image.caption === undefined || typeof image.caption === 'string')
+  ))) return false
+  if (typeof value.layout !== 'string' || !GALLERY_LAYOUTS.includes(value.layout)) return false
+  if (value.styles !== undefined) {
+    if (!isRecord(value.styles)) return false
+    if (!Object.values(value.styles).every(item => typeof item === 'string')) return false
+  }
+  if (value.options !== undefined) {
+    if (!isRecord(value.options)) return false
+    for (const key of GALLERY_BOOLEAN_OPTIONS) {
+      if (value.options[key] !== undefined && typeof value.options[key] !== 'boolean') return false
+    }
+    if (value.options.autoplayInterval !== undefined
+      && (typeof value.options.autoplayInterval !== 'number'
+        || !Number.isFinite(value.options.autoplayInterval)
+        || value.options.autoplayInterval <= 0)) return false
+  }
+  return true
+}
+
+/** @param {unknown} data */
+export function validateEmbedData(data) {
+  if (!isRecord(data)) return false
+  const value = /** @type {Record<string, unknown>} */ (data)
+  if (!hasOptionalStrings(value, OPTIONAL_EMBED_STRINGS)) return false
+  if (value.cover !== undefined && !isCanonicalUrl(value.cover, 'media', true)) return false
+  if (value.service === 'youtube') return typeof value.videoId === 'string' && /^[A-Za-z0-9_-]{11}$/.test(value.videoId)
+  if (value.service === 'vimeo') return typeof value.videoId === 'string' && /^\d+$/.test(value.videoId)
+  return false
+}
+
+/** @param {unknown} data */
+export function validateLinkPreviewData(data) {
+  if (!isRecord(data)) return false
+  const value = /** @type {Record<string, unknown>} */ (data)
+  if (typeof value.url !== 'string'
+    || sanitizeUrl(value.url, { policy: 'external', allowRelative: false, fallback: '' }) !== value.url) return false
+  if (!hasOptionalStrings(value, OPTIONAL_LINK_PREVIEW_STRINGS)) return false
+  if (!isCanonicalUrl(value.image, 'media', true) || !isCanonicalUrl(value.favicon, 'media', true)) return false
+  return value.template === undefined
+    || (typeof value.template === 'string' && LINK_PREVIEW_TEMPLATES.includes(value.template))
+}
+
+/** @param {unknown} data */
+export function validateImageData(data) {
+  if (!isRecord(data)) return false
+  const value = /** @type {Record<string, unknown>} */ (data)
+  if (!isRecord(value.file) || !isCanonicalUrl(value.file.url, 'media')) return false
+  for (const key of ['width', 'height']) {
+    const dimension = value.file[key]
+    if (dimension !== undefined
+      && (typeof dimension !== 'number' || !Number.isFinite(dimension) || dimension <= 0)) return false
+  }
+  if (value.caption !== undefined && typeof value.caption !== 'string') return false
+  for (const key of ['withBorder', 'expanded', 'withBackground']) {
+    if (value[key] !== undefined && typeof value[key] !== 'boolean') return false
+  }
+  return value.styles === undefined
+    || (isRecord(value.styles) && Object.values(value.styles).every(item => typeof item === 'string'))
+}
+
+/** @param {unknown} data */
+export function validateAttachesData(data) {
+  if (!isRecord(data)) return false
+  const value = /** @type {Record<string, unknown>} */ (data)
+  if (value.variant !== undefined && (typeof value.variant !== 'string' || !ATTACH_VARIANTS.has(value.variant))) return false
+  const files = Array.isArray(value.files)
+    ? value.files
+    : (isRecord(value.file) ? [value.file] : null)
+  return Array.isArray(files) && files.length > 0 && files.every(file => (
+    isRecord(file)
+    && isCanonicalUrl(file.url, 'download')
+    && typeof file.name === 'string'
+    && typeof file.extension === 'string'
+    && typeof file.size === 'number'
+    && Number.isFinite(file.size)
+    && file.size >= 0
+  ))
+}
+
+/** @param {unknown} data */
+export function validatePersonData(data) {
+  if (!isRecord(data)) return false
+  const persons = /** @type {Record<string, unknown>} */ (data).persons
+  return Array.isArray(persons) && persons.length > 0 && persons.every(person => (
+    isRecord(person)
+    && typeof person.name === 'string'
+    && typeof person.role === 'string'
+    && typeof person.bio === 'string'
+    && isCanonicalUrl(person.avatar, 'media', true)
+    && Array.isArray(person.links)
+    && person.links.every(link => (
+      isRecord(link)
+      && typeof link.type === 'string'
+      && isCanonicalUrl(link.url, 'link')
+    ))
+  ))
+}
+
+export const BLOCK_DATA_VALIDATORS = Object.freeze({
+  attaches: validateAttachesData,
+  carousel: validateCarouselData,
+  checklist: validateChecklistData,
+  code: validateCodeData,
+  columns: validateColumnsData,
+  delimiter: validateDelimiterData,
+  embed: validateEmbedData,
+  gallery: validateGalleryData,
+  heading: validateHeadingData,
+  image: validateImageData,
+  linkPreview: validateLinkPreviewData,
+  list: validateListData,
+  paragraph: validateParagraphData,
+  person: validatePersonData,
+  poll: validatePollData,
+  quote: validateQuoteData,
+  raw: validateRawData,
+  spoiler: validateSpoilerData,
+  table: validateTableData,
+  toggle: validateToggleData,
+  warning: validateWarningData,
+})
+
+/** @param {string} type @param {unknown} data */
+export function validateKnownBlockData(type, data) {
+  const validator = BLOCK_DATA_VALIDATORS[type]
+  return validator ? validator(data) : false
+}

package/dist/shared/blockTypes.d.ts

@@ -0,0 +1,2 @@
+/** Canonical order shared by synchronous and asynchronous full presets. */
+export const BLOCK_TYPES: readonly ["paragraph", "heading", "list", "quote", "code", "image", "delimiter", "table", "checklist", "warning", "embed", "raw", "gallery", "carousel", "attaches", "linkPreview", "toggle", "columns", "spoiler", "poll", "person"];

package/dist/shared/blockTypes.js

@@ -0,0 +1,26 @@
+// @ts-check
+
+/** Canonical order shared by synchronous and asynchronous full presets. */
+export const BLOCK_TYPES = Object.freeze(/** @type {const} */ ([
+  'paragraph',
+  'heading',
+  'list',
+  'quote',
+  'code',
+  'image',
+  'delimiter',
+  'table',
+  'checklist',
+  'warning',
+  'embed',
+  'raw',
+  'gallery',
+  'carousel',
+  'attaches',
+  'linkPreview',
+  'toggle',
+  'columns',
+  'spoiler',
+  'poll',
+  'person',
+]))

package/dist/shared/carouselData.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Normalize a CSS aspect-ratio value accepted by the carousel contract.
+ * Both numeric components must be finite and strictly positive.
+ *
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+export function normalizeCarouselAspectRatio(value: unknown): string | undefined;
+/** @param {unknown} input @param {() => string} createId @returns {CarouselData} */
+export function normalizeCarouselData(input: unknown, createId: () => string): CarouselData;
+/** @param {unknown} data */
+export function validateCarouselData(data: unknown): boolean;
+export type CarouselSlide = {
+    id: string;
+    type: "image" | "video" | "html";
+    src?: string;
+    alt?: string;
+    caption?: string;
+    poster?: string;
+    html?: string;
+};
+export type CarouselOptions = {
+    loop: boolean;
+    autoplay: boolean;
+    autoplayDelay: number;
+    navigation: boolean;
+    pagination: boolean;
+    thumbnails: boolean;
+    aspectRatio?: string;
+};
+export type CarouselData = {
+    slides: CarouselSlide[];
+    options: CarouselOptions;
+};