@vectoriox/iox-ui 4.34.0 → 4.35.0

package/fesm2022/vectoriox-iox-ui.mjs

@@ -2090,7 +2090,7 @@ function buildSwiperBreakpoints(inputs, responsive) {
     let previous = null;
     // Narrowest → widest, so "same as the band below" is a comparison against what we just emitted.
     for (const band of [...bands].reverse()) {
-        const resolved = pick(resolveInputs(inputs, responsive, band.id));
+        const resolved = pick$1(resolveInputs(inputs, responsive, band.id));
         if (previous && sameValues(previous, resolved))
             continue;
         map[band.minWidth] = resolved;
@@ -2133,7 +2133,7 @@ function bandsWidestFirst() {
         return { id: def.id, minWidth };
     });
 }
-function pick(resolved) {
+function pick$1(resolved) {
     const out = {};
     for (const name of SWIPER_RESPONSIVE_TRAITS) {
         if (resolved[name] !== undefined)
@@ -5466,6 +5466,588 @@ function resolvePath(obj, path) {
     }, obj);
 }
 
+/**
+ * Resolve one binding's value out of its already-selected source data: path lookup, then pipes.
+ *
+ * Trivial on its own, which is exactly why it had been retyped at three call sites — the engine's
+ * string renderer, the engine's component renderer and the builder canvas — plus a fourth needed by
+ * page SEO. `resolvePath` itself was forked five times before it was shared, and the copy that
+ * drifted caused a repeater to render in the SSR HTML and then blank on hydration.
+ *
+ * What is NOT here: picking the source (`resolvedData[binding.source]`) and deciding what an empty
+ * context slot means. Those are per-renderer policy — the string renderer clears the prop, the
+ * builder skips it — so they stay with the caller.
+ */
+function resolveBoundValue(sourceData, binding, ctx = {}) {
+    const raw = binding.path ? resolvePath(sourceData, binding.path) : sourceData;
+    return applyBindingPipes(raw, binding.pipes, ctx);
+}
+
+/**
+ * The canonical shape of a page's SEO metadata, plus the flat tag list both renderers emit.
+ *
+ * ⚠️ This file is the ONLY declaration of that shape. Before it existed, `iox-cms` stored
+ * `seo.og.title` while the SSR engine read a flat `seo.ogTitle`, so no Open Graph tag had ever been
+ * emitted, and `iox-cms-client` carried a third, hand-copied variant of the same schema. See
+ * iox-ai-guidance `architecture/cms/seo-plan.md`.
+ */
+/**
+ * The text fields that can carry a binding, as dotted paths into the document.
+ *
+ * One list, used by the resolver and (phase 2) by the panel that draws the bind affordance — so a
+ * field can never be bindable in the UI and ignored at render time. `robots`, `sitemap.*` and
+ * `structuredData` are deliberately absent: they are pick-lists and blobs, not prose.
+ */
+const SEO_BINDABLE_FIELDS = [
+    'title',
+    'description',
+    'canonicalUrl',
+    'og.title',
+    'og.description',
+    'og.image',
+    'twitter.title',
+    'twitter.description',
+    'twitter.image',
+];
+/**
+ * The bottom rung of the ladder, as a table rather than a chain of ifs.
+ *
+ * Deliberately short. `og:title` and `twitter:*` are NOT here — `seoToTags` already falls back to
+ * the page title for them, and materialising a copy of a value we did not author would only make
+ * later drift harder to see.
+ */
+const SEO_AUTO_SOURCES = [
+    { field: 'title', source: 'contentTitle' },
+    { field: 'description', source: 'contentDescription' },
+    { field: 'og.image', source: 'contentImage' },
+    { field: 'canonicalUrl', source: 'pageUrl' },
+];
+/** Recommended maximum before search results truncate the title. */
+const SEO_TITLE_MAX = 60;
+/** Recommended maximum before search results truncate the description. */
+const SEO_DESCRIPTION_MAX = 160;
+const SEO_ROBOTS_OPTIONS = [
+    { label: 'Index, Follow', value: 'index, follow' },
+    { label: 'Index, No Follow', value: 'index, nofollow' },
+    { label: 'No Index, Follow', value: 'noindex, follow' },
+    { label: 'No Index, No Follow', value: 'noindex, nofollow' },
+];
+const SEO_TWITTER_CARD_OPTIONS = [
+    { label: 'Summary', value: 'summary' },
+    { label: 'Summary Large Image', value: 'summary_large_image' },
+    { label: 'App', value: 'app' },
+    { label: 'Player', value: 'player' },
+];
+const SEO_CHANGE_FREQ_OPTIONS = [
+    { label: 'Always', value: 'always' },
+    { label: 'Hourly', value: 'hourly' },
+    { label: 'Daily', value: 'daily' },
+    { label: 'Weekly', value: 'weekly' },
+    { label: 'Monthly', value: 'monthly' },
+    { label: 'Yearly', value: 'yearly' },
+    { label: 'Never', value: 'never' },
+];
+
+/**
+ * Coerce whatever a page document happens to hold into a `SeoDoc`.
+ *
+ * Every consumer calls this before reading `seo`, because four shapes are in the wild:
+ *  • the current nested shape (`og.title`);
+ *  • the flat shape the SSR engine used to read (`ogTitle`) — never actually written, but a
+ *    document hand-edited against the old engine code could carry it;
+ *  • `""` for "not set", which must not become an empty `<meta>`;
+ *  • `{ override: '…' }`, the per-field value object that plan phase 2 introduces — tolerated here
+ *    so the ladder can land without a second normalizer.
+ *
+ * Empty branches are dropped rather than left as `{}`, so `if (seo.og)` is a meaningful test.
+ */
+function normalizeSeoDoc(raw) {
+    const src = asRecord(raw);
+    if (!src)
+        return {};
+    const og = compact({
+        title: seoString(pick(src, 'og', 'title') ?? src['ogTitle']),
+        description: seoString(pick(src, 'og', 'description') ?? src['ogDescription']),
+        image: seoString(pick(src, 'og', 'image') ?? src['ogImage']),
+    });
+    const twitter = compact({
+        card: seoString(pick(src, 'twitter', 'card')),
+        title: seoString(pick(src, 'twitter', 'title')),
+        description: seoString(pick(src, 'twitter', 'description')),
+        image: seoString(pick(src, 'twitter', 'image')),
+    });
+    const sitemap = compact({
+        include: bool(pick(src, 'sitemap', 'include')),
+        priority: num(pick(src, 'sitemap', 'priority')),
+        changeFreq: seoString(pick(src, 'sitemap', 'changeFreq')),
+    });
+    const structuredData = structured(src['structuredData']);
+    const doc = compact({
+        title: seoString(src['title']),
+        description: seoString(src['description']),
+        keywords: seoString(src['keywords']),
+        canonicalUrl: seoString(src['canonicalUrl']),
+        robots: seoString(src['robots']),
+        og,
+        twitter,
+        sitemap,
+        structuredData,
+    });
+    return doc ?? {};
+}
+/** Read `src[branch][leaf]` without assuming the branch exists or is an object. */
+function pick(src, branch, leaf) {
+    const nested = asRecord(src[branch]);
+    return nested ? nested[leaf] : undefined;
+}
+/**
+ * A field's value as a trimmed string, or `undefined`. Exported because the resolver needs the exact
+ * same coercion for a value it has just pulled out of a data source.
+ *
+ * Unwraps the value object: a bound or auto field has no `override`, so it correctly resolves to
+ * `undefined` here and `resolveSeo` fills it in from the lower rungs.
+ */
+function seoString(value) {
+    const wrapper = asRecord(value);
+    const raw = wrapper ? wrapper['override'] : value;
+    if (typeof raw === 'number')
+        return String(raw);
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+/**
+ * `UIFormToDTO` can hand back `"true"` / `"false"` for a switch (see
+ * `architecture/cms/shop.md` — the boolean/number coercion pitfall), so accept both.
+ */
+function bool(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return undefined;
+}
+function num(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value !== 'string' || !value.trim().length)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+/** JSON-LD is stored as an object or as a JSON string from the `json` controller. */
+function structured(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.length)
+            return undefined;
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (Array.isArray(value))
+        return value.length ? value : undefined;
+    const record = asRecord(value);
+    return record && Object.keys(record).length ? record : undefined;
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/** Drop `undefined` values and empty nested objects, so absence is always `undefined`. */
+function compact(value) {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry === undefined)
+            continue;
+        out[key] = entry;
+    }
+    return (Object.keys(out).length ? out : undefined);
+}
+
+/**
+ * Turn a page's SEO document into the flat list of head tags to emit.
+ *
+ * Both renderers call this, so a page cannot describe itself differently to a crawler than the
+ * builder previews. The order is fixed and part of the contract: title, description, keywords,
+ * canonical, Open Graph, Twitter, robots.
+ *
+ * Fallbacks are deliberately shallow — `og:title` reuses the page title, `twitter:*` reuses the
+ * Open Graph values — because a social scraper that finds no `og:title` falls back to `<title>`
+ * itself, and duplicating a value we did not author only makes the drift harder to see. The
+ * "derive from the page content" half of the ladder (first h1, first paragraph, first image) is
+ * `resolveSeo`, which runs BEFORE this and hands its output in as a filled-in `SeoDoc`.
+ */
+function seoToTags(seo, ctx = {}) {
+    const doc = normalizeSeoDoc(seo);
+    const tags = [];
+    const title = doc.title ?? trimmed(ctx.fallbackTitle);
+    if (title)
+        tags.push({ kind: 'title', content: title });
+    if (doc.description)
+        tags.push({ kind: 'meta', attr: 'name', key: 'description', content: doc.description });
+    if (doc.keywords)
+        tags.push({ kind: 'meta', attr: 'name', key: 'keywords', content: doc.keywords });
+    if (doc.canonicalUrl)
+        tags.push({ kind: 'link', rel: 'canonical', href: doc.canonicalUrl });
+    // Open Graph. `og:url` reuses the canonical URL, which is what it means.
+    const ogTitle = doc.og?.title ?? title;
+    const ogDescription = doc.og?.description ?? doc.description;
+    if (ogTitle)
+        tags.push({ kind: 'meta', attr: 'property', key: 'og:title', content: ogTitle });
+    if (ogDescription)
+        tags.push({ kind: 'meta', attr: 'property', key: 'og:description', content: ogDescription });
+    if (doc.og?.image)
+        tags.push({ kind: 'meta', attr: 'property', key: 'og:image', content: doc.og.image });
+    if (doc.canonicalUrl)
+        tags.push({ kind: 'meta', attr: 'property', key: 'og:url', content: doc.canonicalUrl });
+    // Twitter. Emitted ONLY when a card type is chosen: without `twitter:card` the other tags are
+    // ignored anyway, so writing them would be noise that looks like configuration.
+    if (doc.twitter?.card) {
+        tags.push({ kind: 'meta', attr: 'name', key: 'twitter:card', content: doc.twitter.card });
+        const twitterTitle = doc.twitter.title ?? ogTitle;
+        const twitterDescription = doc.twitter.description ?? ogDescription;
+        const twitterImage = doc.twitter.image ?? doc.og?.image;
+        if (twitterTitle)
+            tags.push({ kind: 'meta', attr: 'name', key: 'twitter:title', content: twitterTitle });
+        if (twitterDescription) {
+            tags.push({ kind: 'meta', attr: 'name', key: 'twitter:description', content: twitterDescription });
+        }
+        if (twitterImage)
+            tags.push({ kind: 'meta', attr: 'name', key: 'twitter:image', content: twitterImage });
+    }
+    if (doc.robots)
+        tags.push({ kind: 'meta', attr: 'name', key: 'robots', content: doc.robots });
+    return tags;
+}
+function trimmed(value) {
+    const out = value?.trim();
+    return out?.length ? out : undefined;
+}
+
+/**
+ * The authoring schema for the `seo` object, in the platform's standard property dialect: `label`
+ * at property level, rendering metadata under `controller`.
+ *
+ * ONE builder, two callers: `iox-cms` spreads it into `PagesSchema` (the stored schema) and
+ * `iox-cms-client` feeds it to `<dynamic-form>`. Those used to be two hand-written copies that had
+ * already drifted — different controller types for the same field, and the client's copy missing
+ * `structuredData` entirely.
+ *
+ * `keywords` is deliberately absent: the tag is emitted when a document carries one, but there is
+ * no reason to invite new ones.
+ */
+function buildSeoSchemaProperties() {
+    return {
+        title: {
+            type: 'string',
+            label: 'Meta Title',
+            controller: {
+                type: 'text',
+                placeholder: 'Page title for search engines',
+                maxLength: SEO_TITLE_MAX,
+            },
+        },
+        description: {
+            type: 'string',
+            label: 'Meta Description',
+            controller: {
+                type: 'textarea',
+                placeholder: 'Brief description for search results',
+                maxLength: SEO_DESCRIPTION_MAX,
+            },
+        },
+        canonicalUrl: {
+            type: 'string',
+            label: 'Canonical URL',
+            controller: {
+                type: 'text',
+                placeholder: 'https://example.com/page',
+            },
+        },
+        robots: {
+            type: 'string',
+            label: 'Robots',
+            controller: {
+                type: 'select',
+                options: SEO_ROBOTS_OPTIONS.map(option => ({ ...option })),
+            },
+        },
+        og: {
+            type: 'object',
+            label: 'Open Graph',
+            controller: { type: 'object' },
+            properties: {
+                title: {
+                    type: 'string',
+                    label: 'OG Title',
+                    controller: { type: 'text', placeholder: 'Title for social sharing' },
+                },
+                description: {
+                    type: 'string',
+                    label: 'OG Description',
+                    controller: { type: 'textarea', placeholder: 'Description for social sharing' },
+                },
+                image: {
+                    type: 'string',
+                    label: 'OG Image',
+                    controller: { type: 'image' },
+                },
+            },
+        },
+        twitter: {
+            type: 'object',
+            label: 'Twitter Card',
+            controller: { type: 'object' },
+            properties: {
+                card: {
+                    type: 'string',
+                    label: 'Card Type',
+                    controller: {
+                        type: 'select',
+                        options: SEO_TWITTER_CARD_OPTIONS.map(option => ({ ...option })),
+                    },
+                },
+                title: {
+                    type: 'string',
+                    label: 'Twitter Title',
+                    controller: { type: 'text' },
+                },
+                description: {
+                    type: 'string',
+                    label: 'Twitter Description',
+                    controller: { type: 'textarea' },
+                },
+                image: {
+                    type: 'string',
+                    label: 'Twitter Image',
+                    controller: { type: 'image' },
+                },
+            },
+        },
+        structuredData: {
+            type: 'object',
+            label: 'Structured Data (JSON-LD)',
+            controller: { type: 'json' },
+        },
+        sitemap: {
+            type: 'object',
+            label: 'Sitemap Settings',
+            controller: { type: 'object' },
+            properties: {
+                include: {
+                    type: 'boolean',
+                    label: 'Include in Sitemap',
+                    controller: { type: 'switch' },
+                },
+                priority: {
+                    type: 'number',
+                    label: 'Priority',
+                    controller: { type: 'range', options: { min: 0, max: 1, step: 0.1 } },
+                },
+                changeFreq: {
+                    type: 'string',
+                    label: 'Change Frequency',
+                    controller: {
+                        type: 'select',
+                        options: SEO_CHANGE_FREQ_OPTIONS.map(option => ({ ...option })),
+                    },
+                },
+            },
+        },
+    };
+}
+
+/*
+ * @vectoriox/iox-ui/seo-core — the shared, FRAMEWORK-FREE core of page SEO.
+ *
+ * ⚠️ Nothing in this entry point may import Angular, RxJS, the DOM, or Node. It is consumed by
+ * THREE runtimes: the builder panel (Angular), the SSR engine (Angular), and `iox-cms` (NestJS,
+ * plain Node) — the same reason `forms-core` exists.
+ *
+ * A page describes itself to a crawler exactly once: `seoToTags` is the only place that decides
+ * which head tags a page emits, and `buildSeoSchemaProperties` the only place that declares what an
+ * author can fill in. See iox-ai-guidance `architecture/cms/seo-plan.md`.
+ */
+
+/** `SeoBinding.pipes` is typed loosely in the framework-free core; narrow it once, here. */
+function boundSpec(binding) {
+    return { path: binding.path, pipes: binding.pipes };
+}
+function resolveSeo(seo, ctx = {}) {
+    // Rung 1 is exactly what the normalizer already produces: overrides, plus every non-bindable
+    // field (robots, sitemap, structuredData) carried through untouched.
+    const out = normalizeSeoDoc(seo);
+    const raw = (seo && typeof seo === 'object' && !Array.isArray(seo) ? seo : {});
+    // Derivation walks the whole tree, so do it once and only if some field will actually ask.
+    let derived;
+    const content = () => (derived ??= deriveSeoFromContent(ctx.tree, ctx.resolvedData));
+    for (const field of SEO_BINDABLE_FIELDS) {
+        if (readField(out, field) !== undefined)
+            continue; // an override won
+        const stored = fieldValue(raw, field);
+        // Rung 2 — the binding.
+        if (stored?.binding) {
+            const value = resolveSeoBinding(stored.binding, ctx.resolvedData);
+            if (value !== undefined) {
+                writeField(out, field, value);
+                continue;
+            }
+        }
+        // Rung 3 — derive it, unless this field opted out.
+        if (stored?.auto === false)
+            continue;
+        const source = SEO_AUTO_SOURCES.find(entry => entry.field === field)?.source;
+        const auto = source ? autoValue(source, content, ctx) : undefined;
+        if (auto !== undefined)
+            writeField(out, field, auto);
+    }
+    // One last pass so a resolved value gets the same trimming and empty-branch dropping as a stored
+    // one — `if (seo.og)` must keep meaning something.
+    return normalizeSeoDoc(out);
+}
+/** Resolve one SEO binding against the page's data. `undefined` when its source did not resolve. */
+function resolveSeoBinding(binding, resolvedData) {
+    const sourceData = resolvedData?.[binding.source];
+    if (sourceData == null)
+        return undefined;
+    return seoString(resolveBoundValue(sourceData, boundSpec(binding)));
+}
+function autoValue(source, content, ctx) {
+    switch (source) {
+        case 'contentTitle':
+            return content().title ?? seoString(ctx.pageName);
+        case 'contentDescription':
+            return content().description;
+        case 'contentImage':
+            return content().image;
+        case 'pageUrl':
+            return seoString(ctx.pageUrl);
+    }
+}
+/**
+ * Derive a title, description and image from the page's own content, in document order.
+ *
+ * ⚠️ Node bindings are resolved here too. On a template page the `<h1>` is normally bound to
+ * `$current.title`, so reading `props.content` alone would return the design-time placeholder — the
+ * same trap that made context slots fall through to component defaults. An unresolved binding yields
+ * nothing rather than the placeholder.
+ *
+ * Node shapes are the renderers' own: `Heading` has `level` + `content`, `Text` has `content` (rich
+ * HTML from the editor) + `tag`, `Image` has `src`.
+ */
+function deriveSeoFromContent(tree, resolvedData) {
+    const out = {};
+    /** A heading that is not an h1 — used only if the page has no h1 at all. */
+    let fallbackHeading;
+    const visit = (nodes) => {
+        for (const node of nodes ?? []) {
+            const current = node;
+            if (!current)
+                continue;
+            const props = resolveNodeProps(current, resolvedData);
+            switch (current['type']) {
+                case 'Heading': {
+                    const text = plainText(props['content']);
+                    if (text) {
+                        if (props['level'] === 'h1')
+                            out.title ??= text;
+                        else
+                            fallbackHeading ??= text;
+                    }
+                    break;
+                }
+                case 'Text': {
+                    // `span` is inline decoration, not a paragraph.
+                    if (props['tag'] !== 'span')
+                        out.description ??= truncate(plainText(props['content']), SEO_DESCRIPTION_MAX);
+                    break;
+                }
+                case 'Image': {
+                    out.image ??= seoString(props['src']);
+                    break;
+                }
+            }
+            visit(current['children']);
+        }
+    };
+    visit(tree);
+    out.title ??= fallbackHeading;
+    return out;
+}
+/** A node's props with its bindings applied — only what derivation reads, never the whole node. */
+function resolveNodeProps(node, resolvedData) {
+    const props = { ...(node['props'] ?? {}) };
+    for (const binding of (node['bindings'] ?? [])) {
+        if (!binding?.prop)
+            continue;
+        const sourceData = resolvedData?.[binding.source];
+        // A bound prop whose source did not resolve must NOT fall through to the design-time default.
+        props[binding.prop] = sourceData == null ? undefined : resolveBoundValue(sourceData, boundSpec(binding));
+    }
+    return props;
+}
+/**
+ * Editor content is rich HTML. Strip it to prose: tags out, block boundaries become spaces so words
+ * do not fuse, the handful of entities an editor emits decoded, whitespace collapsed.
+ */
+function plainText(value) {
+    const raw = seoString(value);
+    if (!raw)
+        return undefined;
+    const text = raw
+        .replace(/<(br|\/p|\/div|\/li|\/h[1-6])\s*\/?>/gi, ' ')
+        .replace(/<[^>]*>/g, '')
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/&amp;/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;|&apos;/gi, "'")
+        .replace(/\s+/g, ' ')
+        .trim();
+    return text.length ? text : undefined;
+}
+/** Cut to `max` characters on a word boundary, with an ellipsis only when something was cut. */
+function truncate(value, max) {
+    if (!value || value.length <= max)
+        return value;
+    const cut = value.slice(0, max - 1);
+    const lastSpace = cut.lastIndexOf(' ');
+    return (lastSpace > max * 0.6 ? cut.slice(0, lastSpace) : cut).trimEnd() + '…';
+}
+// ── dotted-path access over the document, so the field table stays data and not a switch ───────────
+function fieldValue(raw, field) {
+    const value = readField(raw, field);
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function readField(doc, field) {
+    const [branch, leaf] = field.split('.');
+    if (!leaf)
+        return doc[branch];
+    const nested = doc[branch];
+    return nested && typeof nested === 'object' ? nested[leaf] : undefined;
+}
+function writeField(doc, field, value) {
+    const [branch, leaf] = field.split('.');
+    if (!leaf) {
+        doc[branch] = value;
+        return;
+    }
+    const nested = (doc[branch] && typeof doc[branch] === 'object' ? doc[branch] : {});
+    nested[leaf] = value;
+    doc[branch] = nested;
+}
+
 /**
  * Element context state — shared types.
  *
@@ -6153,5 +6735,5 @@ function effectiveTransitionId(anim) {
  * Generated bundle index. Do not edit.
  */
 
-export { AOSService, AnalyticsService, BREAKPOINTS, Breakpoint, BreakpointQueryKind, BuilderButtonComponent, BuilderDividerComponent, BuilderHeadingComponent, BuilderIconComponent, BuilderImageComponent, BuilderLinkComponent, BuilderSpacerComponent, ButtonBlockComponent, CMSClientInfraModule, CONTEXT_ACTION_TYPES, CardComponent, ClientGalleryComponent, ClientListComponent, ClientListItemComponent, ClientRepeaterComponent, ClientSliderContainerComponent, ClientSliderSlideComponent, ComponentInstanceRegistryService, ConsentService, ContainerComponent, ContentService, ContextStore, DEFAULT_GALLERY_SCHEDULER, DEFAULT_PAGE_TRANSITION, DEFAULT_PAGE_TRANSITION_DURATION, DEFAULT_PAGE_TRANSITION_EASING, DEFAULT_PAGE_TRANSITION_PERSPECTIVE, DEFAULT_WIDTH_BY_TYPE, DeclarationContext, ENVIRONMENT, FormRenderState, FormRuntimeService, GALLERY_EFFECTS, GALLERY_EFFECT_DESCRIPTORS, GalleryLoop, IOX_BUILDER_EVENTS, IOX_FORM_MESSAGES, IOX_FORM_NAVIGATOR, IOX_FORM_TRANSPORT, IS_PREVIEW, IoxAnimateContainer, IoxAosDirective, IoxAosModule, IoxBuilderComponentsModule, IoxComponentRegistryService, IoxFieldComponent, IoxFormComponent, IoxFormErrorComponent, IoxFormSuccessComponent, IoxPageComponent, IoxPageModule, IoxSubmitButtonComponent, IoxUiModule, LinkedContainerComponent, PAGE_TRANSITION_CATEGORIES, PAGE_TRANSITION_PRESETS, PIPE_DESCRIPTORS, PIPE_REGISTRY, PageScrollProvider, PrivacyModalComponent, PrivacyModalService, PrivacyModelEvent, RESERVED_ALIAS_PREFIX, SUPPRESSED_STYLE_PROPS_BY_TYPE, SWIPER_RESPONSIVE_TRAITS, SectionComponent, TRANSITION_FEELS, TextBlockComponent, VIRTUAL_TRAIT_GROUPS, VIRTUAL_TRAIT_KEYS, ViewPositionDirective, ViewPositionModule, WebSettingsService, activeActions, applyBindingPipes, applyFeel, breakpointDef, breakpointForWidth, breakpointQueryFor, buildDataSourceFilter, buildRelatedFilter, buildSwiperBreakpoints, buildTargetedStateSelector, buildTransitionTimeline, cascadeChain, clearInputOverride, clearOverride, collectContextSlotKeys, collectReferencedAliases, compileDeclarations, composeVirtualTraits, computeRelative, contextActionEffect, contextSlotKeys, countOverrides, dataSourcePlanToRequest, declaredInputNames, defaultMessageResolver, effectiveTransitionId, excludeSelf, feelFor, getByPath, initialSlotValues, isActionEnabled, isContextAction, isInputOverriddenAt, isOverriddenAt, isReservedAlias, isValidSlotKey, legacyEnterToTransition, matchRouteParams, mediaQueryFor, mergeSwiperBreakpoints, nearestCommonAncestorId, nodeCssId, nodeUsesContext, normalizeCollectionResult, normalizeGalleryImage, parentBreakpoint, parseUrlList, planDataSource, planResponsiveRules, referencedDataSources, referencedDataSourcesDeep, renderDefaultDeclarations, resolveContextValue, resolveDerivedInto, resolveGalleryEffect, resolveGalleryUrls, resolveInputChain, resolveInputs, resolvePageTransition, resolvePath, resolveRelativeInto, resolveRepeaterItems, resolveSiblings, resolveSingleItemId, resolveStateStyles, resolveStyleProps, resolveValueChain, rewriteViewportUnits, safeSetInput, setInputOverride, setOverride, stateNamesIn, stripSuppressedProps, styleKeyToKebab, variableAliases, variableItemsFrom, withContextSlots, wrapInBreakpointQuery, wrapInMediaQuery };
+export { AOSService, AnalyticsService, BREAKPOINTS, Breakpoint, BreakpointQueryKind, BuilderButtonComponent, BuilderDividerComponent, BuilderHeadingComponent, BuilderIconComponent, BuilderImageComponent, BuilderLinkComponent, BuilderSpacerComponent, ButtonBlockComponent, CMSClientInfraModule, CONTEXT_ACTION_TYPES, CardComponent, ClientGalleryComponent, ClientListComponent, ClientListItemComponent, ClientRepeaterComponent, ClientSliderContainerComponent, ClientSliderSlideComponent, ComponentInstanceRegistryService, ConsentService, ContainerComponent, ContentService, ContextStore, DEFAULT_GALLERY_SCHEDULER, DEFAULT_PAGE_TRANSITION, DEFAULT_PAGE_TRANSITION_DURATION, DEFAULT_PAGE_TRANSITION_EASING, DEFAULT_PAGE_TRANSITION_PERSPECTIVE, DEFAULT_WIDTH_BY_TYPE, DeclarationContext, ENVIRONMENT, FormRenderState, FormRuntimeService, GALLERY_EFFECTS, GALLERY_EFFECT_DESCRIPTORS, GalleryLoop, IOX_BUILDER_EVENTS, IOX_FORM_MESSAGES, IOX_FORM_NAVIGATOR, IOX_FORM_TRANSPORT, IS_PREVIEW, IoxAnimateContainer, IoxAosDirective, IoxAosModule, IoxBuilderComponentsModule, IoxComponentRegistryService, IoxFieldComponent, IoxFormComponent, IoxFormErrorComponent, IoxFormSuccessComponent, IoxPageComponent, IoxPageModule, IoxSubmitButtonComponent, IoxUiModule, LinkedContainerComponent, PAGE_TRANSITION_CATEGORIES, PAGE_TRANSITION_PRESETS, PIPE_DESCRIPTORS, PIPE_REGISTRY, PageScrollProvider, PrivacyModalComponent, PrivacyModalService, PrivacyModelEvent, RESERVED_ALIAS_PREFIX, SUPPRESSED_STYLE_PROPS_BY_TYPE, SWIPER_RESPONSIVE_TRAITS, SectionComponent, TRANSITION_FEELS, TextBlockComponent, VIRTUAL_TRAIT_GROUPS, VIRTUAL_TRAIT_KEYS, ViewPositionDirective, ViewPositionModule, WebSettingsService, activeActions, applyBindingPipes, applyFeel, breakpointDef, breakpointForWidth, breakpointQueryFor, buildDataSourceFilter, buildRelatedFilter, buildSwiperBreakpoints, buildTargetedStateSelector, buildTransitionTimeline, cascadeChain, clearInputOverride, clearOverride, collectContextSlotKeys, collectReferencedAliases, compileDeclarations, composeVirtualTraits, computeRelative, contextActionEffect, contextSlotKeys, countOverrides, dataSourcePlanToRequest, declaredInputNames, defaultMessageResolver, deriveSeoFromContent, effectiveTransitionId, excludeSelf, feelFor, getByPath, initialSlotValues, isActionEnabled, isContextAction, isInputOverriddenAt, isOverriddenAt, isReservedAlias, isValidSlotKey, legacyEnterToTransition, matchRouteParams, mediaQueryFor, mergeSwiperBreakpoints, nearestCommonAncestorId, nodeCssId, nodeUsesContext, normalizeCollectionResult, normalizeGalleryImage, parentBreakpoint, parseUrlList, planDataSource, planResponsiveRules, referencedDataSources, referencedDataSourcesDeep, renderDefaultDeclarations, resolveBoundValue, resolveContextValue, resolveDerivedInto, resolveGalleryEffect, resolveGalleryUrls, resolveInputChain, resolveInputs, resolvePageTransition, resolvePath, resolveRelativeInto, resolveRepeaterItems, resolveSeo, resolveSiblings, resolveSingleItemId, resolveStateStyles, resolveStyleProps, resolveValueChain, rewriteViewportUnits, safeSetInput, setInputOverride, setOverride, stateNamesIn, stripSuppressedProps, styleKeyToKebab, variableAliases, variableItemsFrom, withContextSlots, wrapInBreakpointQuery, wrapInMediaQuery };
 //# sourceMappingURL=vectoriox-iox-ui.mjs.map