@velastack/cms 0.5.0 → 0.6.0

package/dist/core/shapes/collection.js

@@ -0,0 +1,194 @@
+import { asBoolean, asItems, asNumber, asString, asStrings, isPlainObject } from '../structured.js';
+import { defineForm } from './form.js';
+import { asImage, asImages } from './image.js';
+import { asLink, linkHref } from './link.js';
+export const cmsCollection = defineForm({
+    component: 'CmsCollection',
+    label: 'Collection',
+    version: 1,
+    translatable: [],
+    items: {
+        key: 'items',
+        translatable: [
+            'title',
+            'summary',
+            'body',
+            'duration',
+            'tags',
+            'features',
+            'price.period',
+            'price.prefix'
+        ],
+        items: { key: 'details', translatable: ['label', 'value'] }
+    },
+    normalize: (raw) => {
+        const items = Array.isArray(raw) ? raw : isPlainObject(raw) ? raw.items : [];
+        return {
+            v: 1,
+            items: asItems(items, (r) => {
+                const p = isPlainObject(r.price) ? r.price : {};
+                return {
+                    title: asString(r.title),
+                    summary: asString(r.summary),
+                    body: asString(r.body),
+                    image: asImage(r.image),
+                    gallery: asImages(r.gallery),
+                    price: {
+                        amount: asNumber(p.amount),
+                        currency: asString(p.currency),
+                        period: asString(p.period),
+                        prefix: asString(p.prefix)
+                    },
+                    duration: asString(r.duration),
+                    link: asLink(r.link),
+                    tags: asStrings(r.tags).filter((t) => t !== ''),
+                    features: asStrings(r.features).filter((f) => f !== ''),
+                    featured: asBoolean(r.featured),
+                    hidden: asBoolean(r.hidden),
+                    details: asItems(r.details, (d) => ({
+                        label: asString(d.label),
+                        value: asString(d.value)
+                    }))
+                };
+            })
+        };
+    },
+    empty: () => ({ v: 1, items: [] }),
+    fields: [
+        {
+            key: 'items',
+            label: 'Items',
+            type: 'list',
+            itemLabel: 'item',
+            titleKey: 'title',
+            blank: () => ({
+                title: '',
+                summary: '',
+                body: '',
+                image: null,
+                gallery: [],
+                price: { amount: null, currency: '', period: '', prefix: '' },
+                duration: '',
+                link: null,
+                tags: [],
+                features: [],
+                featured: false,
+                hidden: false,
+                details: []
+            }),
+            fields: [
+                { key: 'title', label: 'Title', type: 'text', group: 'Details' },
+                { key: 'summary', label: 'Summary', type: 'long-string', group: 'Details' },
+                { key: 'body', label: 'Body', type: 'html', group: 'Details' },
+                {
+                    key: 'duration',
+                    label: 'Duration',
+                    type: 'text',
+                    half: true,
+                    placeholder: '3 hours',
+                    group: 'Details'
+                },
+                { key: 'link', label: 'Link', type: 'link', group: 'Details' },
+                {
+                    key: 'tags',
+                    label: 'Tags',
+                    type: 'strings',
+                    placeholder: 'One per line',
+                    group: 'Details'
+                },
+                {
+                    key: 'features',
+                    label: 'Features',
+                    type: 'strings',
+                    placeholder: 'One per line',
+                    group: 'Details'
+                },
+                {
+                    key: 'details',
+                    label: 'Details',
+                    type: 'list',
+                    itemLabel: 'detail',
+                    titleKey: 'label',
+                    group: 'Details',
+                    blank: () => ({ label: '', value: '' }),
+                    fields: [
+                        { key: 'label', label: 'Label', type: 'text', half: true, placeholder: 'Sleeps' },
+                        { key: 'value', label: 'Value', type: 'text', placeholder: '4' }
+                    ]
+                },
+                { key: 'featured', label: 'Featured', type: 'boolean', group: 'Details' },
+                { key: 'hidden', label: 'Hidden', type: 'boolean', group: 'Details' },
+                { key: 'image', label: 'Image', type: 'image', group: 'Media' },
+                { key: 'gallery', label: 'Gallery', type: 'images', group: 'Media' },
+                {
+                    key: 'price.prefix',
+                    label: 'Prefix',
+                    type: 'text',
+                    half: true,
+                    placeholder: 'from',
+                    group: 'Pricing'
+                },
+                { key: 'price.amount', label: 'Amount', type: 'number', group: 'Pricing' },
+                {
+                    key: 'price.currency',
+                    label: 'Currency',
+                    type: 'text',
+                    half: true,
+                    placeholder: 'EUR',
+                    group: 'Pricing'
+                },
+                { key: 'price.period', label: 'Per', type: 'text', placeholder: 'night', group: 'Pricing' }
+            ]
+        }
+    ]
+});
+/** Visible items (not hidden, with a title), optionally sliced. */
+export const collectionView = (value, slice = {}) => {
+    let items = value.items.filter((i) => !i.hidden && i.title !== '');
+    if (slice.featured)
+        items = items.filter((i) => i.featured);
+    if (slice.tag)
+        items = items.filter((i) => i.tags.includes(slice.tag));
+    if (slice.limit !== undefined && slice.limit >= 0)
+        items = items.slice(0, slice.limit);
+    return items.map((i) => ({ ...i, href: i.link ? linkHref(i.link) || null : null }));
+};
+/** Every tag in use, in first-seen order. */
+export const collectionTags = (value) => {
+    const out = [];
+    for (const item of value.items)
+        for (const t of item.tags)
+            if (!out.includes(t))
+                out.push(t);
+    return out;
+};
+/** `from €120 / night`, or empty when there is no amount. */
+export const formatCollectionPrice = (price, locale) => {
+    if (price.amount === null)
+        return '';
+    let amount;
+    try {
+        amount = price.currency
+            ? new Intl.NumberFormat(locale, {
+                style: 'currency',
+                currency: price.currency,
+                maximumFractionDigits: Number.isInteger(price.amount) ? 0 : 2
+            }).format(price.amount)
+            : new Intl.NumberFormat(locale).format(price.amount);
+    }
+    catch {
+        amount = `${price.currency} ${price.amount}`.trim();
+    }
+    return [price.prefix, amount, price.period ? `/ ${price.period}` : ''].filter(Boolean).join(' ');
+};
+/** A schema.org `ItemList` of the visible items. */
+export const toItemList = (value, baseUrl = '') => ({
+    '@context': 'https://schema.org',
+    '@type': 'ItemList',
+    itemListElement: collectionView(value).map((i, n) => {
+        const item = { '@type': 'ListItem', position: n + 1, name: i.title };
+        if (i.href)
+            item.url = baseUrl + i.href;
+        return item;
+    })
+});

package/dist/core/shapes/contact.d.ts

@@ -0,0 +1,70 @@
+/**
+ * `CmsContact`: where and how to reach the business. Labels translate;
+ * addresses and numbers do not. `contactView` adds the hrefs and the
+ * formatted address a template renders.
+ */
+import type { Tree } from '../path.js';
+export type ContactPhone = {
+    id: string;
+    label: string;
+    number: string;
+};
+export type ContactEmail = {
+    id: string;
+    label: string;
+    address: string;
+};
+export type ContactAddress = {
+    lines: string[];
+    locality: string;
+    region: string;
+    postcode: string;
+    country: string;
+};
+export type ContactLabels = {
+    address: string;
+    phone: string;
+    email: string;
+    whatsapp: string;
+    directions: string;
+};
+export type CmsContactValue = {
+    v: 1;
+    name: string;
+    address: ContactAddress;
+    phones: ContactPhone[];
+    emails: ContactEmail[];
+    whatsapp: string;
+    directionsUrl: string;
+    geo: {
+        lat: number;
+        lng: number;
+    } | null;
+    labels: ContactLabels;
+};
+export declare const DEFAULT_CONTACT_LABELS: ContactLabels;
+export declare const cmsContact: import("./form.js").FormShape<CmsContactValue>;
+export declare const telHref: (number: string) => string;
+export declare const whatsappHref: (number: string) => string;
+/** Address lines in the country's conventional order, empty parts dropped. */
+export declare const formatAddress: (address: ContactAddress) => string[];
+export type ContactView = Omit<CmsContactValue, 'phones' | 'emails'> & {
+    phones: Array<ContactPhone & {
+        href: string;
+    }>;
+    emails: Array<ContactEmail & {
+        href: string;
+    }>;
+    /** First phone's `tel:` href, or `null`. */
+    telHref: string | null;
+    /** First email's `mailto:`, or `null`. */
+    mailto: string | null;
+    whatsappHref: string | null;
+    /** `directionsUrl`, else a Google Maps link from `geo` or the address. */
+    mapsHref: string | null;
+    formattedAddress: string[];
+    hasAddress: boolean;
+};
+export declare const contactView: (value: CmsContactValue) => ContactView;
+/** A schema.org `PostalAddress` node, or `null` without an address. */
+export declare const toPostalAddress: (value: CmsContactValue) => Tree | null;

package/dist/core/shapes/contact.js

@@ -0,0 +1,214 @@
+import { asItems, asNumber, asString, asStrings, isPlainObject } from '../structured.js';
+import { defineForm } from './form.js';
+export const DEFAULT_CONTACT_LABELS = {
+    address: 'Address',
+    phone: 'Phone',
+    email: 'Email',
+    whatsapp: 'WhatsApp',
+    directions: 'Directions'
+};
+export const cmsContact = defineForm({
+    component: 'CmsContact',
+    label: 'Contact details',
+    version: 1,
+    translatable: [
+        'labels.address',
+        'labels.phone',
+        'labels.email',
+        'labels.whatsapp',
+        'labels.directions'
+    ],
+    items: [
+        { key: 'phones', translatable: ['label'] },
+        { key: 'emails', translatable: ['label'] }
+    ],
+    normalize: (raw) => {
+        const r = isPlainObject(raw) ? raw : {};
+        const a = isPlainObject(r.address) ? r.address : {};
+        const g = isPlainObject(r.geo) ? r.geo : null;
+        const lat = g ? asNumber(g.lat) : null;
+        const lng = g ? asNumber(g.lng) : null;
+        const labels = isPlainObject(r.labels) ? r.labels : {};
+        return {
+            v: 1,
+            name: asString(r.name),
+            address: {
+                lines: asStrings(a.lines).filter((l) => l !== ''),
+                locality: asString(a.locality),
+                region: asString(a.region),
+                postcode: asString(a.postcode),
+                country: asString(a.country)
+            },
+            phones: asItems(r.phones, (p) => ({
+                label: asString(p.label),
+                number: asString(p.number)
+            })),
+            emails: asItems(r.emails, (e) => ({
+                label: asString(e.label),
+                address: asString(e.address)
+            })),
+            whatsapp: asString(r.whatsapp),
+            directionsUrl: asString(r.directionsUrl),
+            geo: lat !== null && lng !== null ? { lat, lng } : null,
+            labels: {
+                address: asString(labels.address, DEFAULT_CONTACT_LABELS.address),
+                phone: asString(labels.phone, DEFAULT_CONTACT_LABELS.phone),
+                email: asString(labels.email, DEFAULT_CONTACT_LABELS.email),
+                whatsapp: asString(labels.whatsapp, DEFAULT_CONTACT_LABELS.whatsapp),
+                directions: asString(labels.directions, DEFAULT_CONTACT_LABELS.directions)
+            }
+        };
+    },
+    empty: () => ({
+        v: 1,
+        name: '',
+        address: { lines: [], locality: '', region: '', postcode: '', country: '' },
+        phones: [],
+        emails: [],
+        whatsapp: '',
+        directionsUrl: '',
+        geo: null,
+        labels: { ...DEFAULT_CONTACT_LABELS }
+    }),
+    fields: [
+        { key: 'name', label: 'Business name', type: 'text' },
+        {
+            key: 'address.lines',
+            label: 'Street address',
+            type: 'strings',
+            placeholder: 'One line per row'
+        },
+        { key: 'address.locality', label: 'City', type: 'text', half: true },
+        { key: 'address.region', label: 'Region', type: 'text' },
+        { key: 'address.postcode', label: 'Postcode', type: 'text', half: true },
+        { key: 'address.country', label: 'Country', type: 'text' },
+        {
+            key: 'phones',
+            label: 'Phone numbers',
+            type: 'list',
+            itemLabel: 'number',
+            titleKey: 'label',
+            blank: () => ({ label: '', number: '' }),
+            fields: [
+                { key: 'label', label: 'Label', type: 'text', half: true, placeholder: 'Front desk' },
+                { key: 'number', label: 'Number', type: 'text', placeholder: '+34 600 000 000' }
+            ]
+        },
+        {
+            key: 'emails',
+            label: 'Email addresses',
+            type: 'list',
+            itemLabel: 'address',
+            titleKey: 'label',
+            blank: () => ({ label: '', address: '' }),
+            fields: [
+                { key: 'label', label: 'Label', type: 'text', half: true, placeholder: 'Bookings' },
+                { key: 'address', label: 'Address', type: 'text', placeholder: 'hello@example.com' }
+            ]
+        },
+        { key: 'whatsapp', label: 'WhatsApp number', type: 'text', group: 'Map & links' },
+        { key: 'directionsUrl', label: 'Directions URL', type: 'url', group: 'Map & links' },
+        { key: 'geo.lat', label: 'Latitude', type: 'number', half: true, group: 'Map & links' },
+        { key: 'geo.lng', label: 'Longitude', type: 'number', group: 'Map & links' },
+        { key: 'labels.address', label: '“Address”', type: 'text', half: true, group: 'Labels' },
+        { key: 'labels.phone', label: '“Phone”', type: 'text', group: 'Labels' },
+        { key: 'labels.email', label: '“Email”', type: 'text', half: true, group: 'Labels' },
+        { key: 'labels.whatsapp', label: '“WhatsApp”', type: 'text', group: 'Labels' },
+        { key: 'labels.directions', label: '“Directions”', type: 'text', group: 'Labels' }
+    ]
+});
+// ---------------------------------------------------------------------------
+// Derived view
+// ---------------------------------------------------------------------------
+export const telHref = (number) => `tel:${number.replace(/[^\d+]/g, '')}`;
+export const whatsappHref = (number) => `https://wa.me/${number.replace(/[^\d]/g, '')}`;
+/** Countries that write the postcode before the locality. Matched on ISO
+ * code or English name, case-insensitively. */
+const POSTCODE_FIRST = new Set([
+    'es',
+    'spain',
+    'fr',
+    'france',
+    'de',
+    'germany',
+    'it',
+    'italy',
+    'pt',
+    'portugal',
+    'nl',
+    'netherlands',
+    'be',
+    'belgium',
+    'at',
+    'austria',
+    'ch',
+    'switzerland',
+    'se',
+    'sweden',
+    'no',
+    'norway',
+    'dk',
+    'denmark',
+    'fi',
+    'finland',
+    'pl',
+    'poland',
+    'cz',
+    'czechia',
+    'mx',
+    'mexico'
+]);
+/** Address lines in the country's conventional order, empty parts dropped. */
+export const formatAddress = (address) => {
+    const { lines, locality, region, postcode, country } = address;
+    const postcodeFirst = POSTCODE_FIRST.has(country.trim().toLowerCase());
+    const cityLine = postcodeFirst
+        ? [postcode, locality].filter(Boolean).join(' ') + (region ? ` (${region})` : '')
+        : [[locality, region].filter(Boolean).join(', '), postcode].filter(Boolean).join(' ');
+    return [...lines, cityLine, country].map((l) => l.trim()).filter((l) => l !== '');
+};
+export const contactView = (value) => {
+    const phones = value.phones
+        .filter((p) => p.number !== '')
+        .map((p) => ({ ...p, href: telHref(p.number) }));
+    const emails = value.emails
+        .filter((e) => e.address !== '')
+        .map((e) => ({ ...e, href: `mailto:${e.address}` }));
+    const formattedAddress = formatAddress(value.address);
+    let mapsHref = value.directionsUrl || null;
+    if (!mapsHref && value.geo) {
+        mapsHref = `https://www.google.com/maps/search/?api=1&query=${value.geo.lat},${value.geo.lng}`;
+    }
+    if (!mapsHref && formattedAddress.length > 0) {
+        mapsHref = `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(formattedAddress.join(', '))}`;
+    }
+    return {
+        ...value,
+        phones,
+        emails,
+        telHref: phones[0]?.href ?? null,
+        mailto: emails[0]?.href ?? null,
+        whatsappHref: value.whatsapp ? whatsappHref(value.whatsapp) : null,
+        mapsHref,
+        formattedAddress,
+        hasAddress: formattedAddress.length > 0
+    };
+};
+/** A schema.org `PostalAddress` node, or `null` without an address. */
+export const toPostalAddress = (value) => {
+    const a = value.address;
+    if (a.lines.length === 0 && !a.locality && !a.postcode && !a.country)
+        return null;
+    const out = { '@type': 'PostalAddress' };
+    if (a.lines.length)
+        out.streetAddress = a.lines.join(', ');
+    if (a.locality)
+        out.addressLocality = a.locality;
+    if (a.region)
+        out.addressRegion = a.region;
+    if (a.postcode)
+        out.postalCode = a.postcode;
+    if (a.country)
+        out.addressCountry = a.country;
+    return out;
+};

package/dist/core/shapes/faq.d.ts

@@ -0,0 +1,12 @@
+import { type ListValue } from './form.js';
+export type FaqItem = {
+    id: string;
+    question: string;
+    answer: string;
+};
+export type CmsFaqValue = ListValue<FaqItem>;
+export declare const cmsFaq: import("./form.js").FormShape<CmsFaqValue>;
+/** Questions that have both a question and an answer. */
+export declare const faqView: (value: CmsFaqValue) => FaqItem[];
+/** A schema.org `FAQPage` node for `<script type="application/ld+json">`. */
+export declare const toFaqPage: (value: CmsFaqValue) => Record<string, unknown>;

package/dist/core/shapes/faq.js

@@ -0,0 +1,48 @@
+/** `CmsFaq`: questions with rich answers, plus FAQPage JSON-LD. */
+import { asItems, asString, isPlainObject } from '../structured.js';
+import { defineForm } from './form.js';
+export const cmsFaq = defineForm({
+    component: 'CmsFaq',
+    label: 'FAQ',
+    version: 1,
+    translatable: [],
+    items: { key: 'items', translatable: ['question', 'answer'] },
+    normalize: (raw) => {
+        const items = Array.isArray(raw) ? raw : isPlainObject(raw) ? raw.items : [];
+        return {
+            v: 1,
+            items: asItems(items, (r) => ({
+                question: asString(r.question),
+                answer: asString(r.answer)
+            }))
+        };
+    },
+    empty: () => ({ v: 1, items: [] }),
+    fields: [
+        {
+            key: 'items',
+            label: 'Questions',
+            type: 'list',
+            itemLabel: 'question',
+            titleKey: 'question',
+            blank: () => ({ question: '', answer: '' }),
+            fields: [
+                { key: 'question', label: 'Question', type: 'text' },
+                { key: 'answer', label: 'Answer', type: 'html' }
+            ]
+        }
+    ]
+});
+const stripTags = (html) => html.replace(/<[^>]*>/g, '').trim();
+/** Questions that have both a question and an answer. */
+export const faqView = (value) => value.items.filter((i) => i.question !== '' && stripTags(i.answer) !== '');
+/** A schema.org `FAQPage` node for `<script type="application/ld+json">`. */
+export const toFaqPage = (value) => ({
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faqView(value).map((i) => ({
+        '@type': 'Question',
+        name: i.question,
+        acceptedAnswer: { '@type': 'Answer', text: i.answer }
+    }))
+});

package/dist/core/shapes/form.d.ts

@@ -0,0 +1,46 @@
+/**
+ * What the generic structured editor renders for a shape. A component's
+ * schema lists its fields; the popover walks them and draws one input per
+ * field. `list` fields hold items (stable `id` each) with their own fields,
+ * so a collection item's details or a pricing tier's features are edited in
+ * place. Templates never see this: they get the typed value.
+ */
+import type { Tree } from '../path.js';
+import { type Structured, type StructuredSchema } from '../structured.js';
+export type FormFieldType = 'text' | 'long-string' | 'html' | 'number' | 'boolean' | 'date' | 'time' | 'url' | 'image' | 'images' | 'enum' | 'link' | 'strings' | 'rating' | 'list';
+export type FormField = {
+    /** Dotted path within the object being edited (`name`, `price.amount`). */
+    key: string;
+    label: string;
+    type: FormFieldType;
+    placeholder?: string;
+    /** `enum`: the stored values, and optional display names. */
+    values?: readonly string[];
+    names?: Readonly<Record<string, string>>;
+    /** Share a row with the next field. */
+    half?: boolean;
+    /** Tab the field sits in. Fields without a group share the first tab. */
+    group?: string;
+    /** `list`: what one item is called ("tier"), its fields, a blank item
+     * (without `id`) and which field titles a collapsed card. */
+    itemLabel?: string;
+    fields?: readonly FormField[];
+    blank?: () => Tree;
+    titleKey?: string;
+};
+export type FormShape<T extends Tree> = Structured<T> & {
+    /** Popover header, e.g. "Opening hours". */
+    label: string;
+    fields: readonly FormField[];
+};
+export declare const defineForm: <T extends Tree>(schema: StructuredSchema<T> & {
+    label: string;
+    fields: readonly FormField[];
+}) => FormShape<T>;
+/** Shared vocabulary for the list-shaped components: `{ v: 1, items }`. */
+export type ListValue<I extends {
+    id: string;
+}> = {
+    v: 1;
+    items: I[];
+};

package/dist/core/shapes/form.js

@@ -0,0 +1,7 @@
+import { defineStructured } from '../structured.js';
+import { registerStructured } from '../structured-registry.js';
+export const defineForm = (schema) => {
+    const { label, fields, ...rest } = schema;
+    const structured = registerStructured(defineStructured(rest));
+    return { ...structured, label, fields };
+};

package/dist/core/shapes/hours.d.ts

@@ -0,0 +1,91 @@
+/**
+ * `CmsHours`: a week of opening hours in the business's timezone, with
+ * holiday exceptions and the labels a template needs around them. The
+ * stored value is data only; `hoursView` derives what the template renders
+ * (folded rows, today, open-now) in the visitor's locale.
+ */
+import type { Tree } from '../path.js';
+export declare const DAY_KEYS: readonly ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+export type DayKey = (typeof DAY_KEYS)[number];
+/** `HH:MM`, 24-hour. */
+export type HoursRange = {
+    open: string;
+    close: string;
+};
+export type DayHours = {
+    closed: boolean;
+    ranges: HoursRange[];
+};
+export type HoursException = {
+    id: string;
+    /** `YYYY-MM-DD` */
+    date: string;
+    label: string;
+    closed: boolean;
+    ranges: HoursRange[];
+};
+export type HoursLabels = {
+    closed: string;
+    today: string;
+    openNow: string;
+    closedNow: string;
+};
+export type CmsHoursValue = {
+    v: 1;
+    /** IANA zone, e.g. `Europe/Madrid`. Empty means the visitor's zone. */
+    timezone: string;
+    days: Record<DayKey, DayHours>;
+    note: string;
+    exceptions: HoursException[];
+    labels: HoursLabels;
+};
+export declare const DEFAULT_HOURS_LABELS: HoursLabels;
+export declare const cmsHours: import("./form.js").FormShape<CmsHoursValue>;
+/** `09:00` → `9:00 AM` (en) / `9:00` (es). */
+export declare const formatTime: (hhmm: string, locale: string) => string;
+/** `9:00 AM – 5:00 PM, 6:00 – 10:00 PM`, or the closed label. */
+export declare const formatRanges: (ranges: HoursRange[], locale: string, closedLabel: string) => string;
+/** Short weekday names in the visitor's locale, Monday first. */
+export declare const dayNames: (locale: string, weekday?: "short" | "long") => Record<DayKey, string>;
+/** The current weekday, date and minute in `timezone` (the visitor's zone when empty or invalid). */
+export declare const zonedNow: (timezone: string, now?: Date) => {
+    key: DayKey;
+    date: string;
+    minutes: number;
+};
+export type HoursRow = {
+    id: string;
+    keys: DayKey[];
+    /** `Mon – Fri`, `Sat`, `Sat, Sun` */
+    days: string;
+    /** Formatted ranges, or the closed label. */
+    text: string;
+    closed: boolean;
+};
+export type HoursToday = {
+    key: DayKey;
+    date: string;
+    /** The value's `labels.today`. */
+    label: string;
+    /** `Mon` in the visitor's locale. */
+    day: string;
+    text: string;
+    closed: boolean;
+    exception: HoursException | null;
+};
+export type HoursExceptionRow = HoursException & {
+    dateText: string;
+    text: string;
+};
+export type HoursView = CmsHoursValue & {
+    rows: HoursRow[];
+    today: HoursToday;
+    isOpenNow: boolean;
+    /** `labels.openNow` or `labels.closedNow`. */
+    status: string;
+    exceptionRows: HoursExceptionRow[];
+};
+export declare const formatDate: (iso: string, locale: string) => string;
+export declare const hoursView: (value: CmsHoursValue, locale: string, now?: Date) => HoursView;
+/** schema.org `openingHoursSpecification` entries, one per distinct range. */
+export declare const toOpeningHoursSpecification: (value: CmsHoursValue) => Tree[];