@vendure-platform/create 0.1.0

package/dist/assets/storefront/src/scenarios/kaminpro/pdp/components/why-panel.tsx

@@ -0,0 +1,66 @@
+'use client';
+
+import type { EvaluatedExecutedRule } from '../lib/types';
+
+interface WhyPanelProps {
+    executedRules: EvaluatedExecutedRule[];
+    open: boolean;
+    onToggle: () => void;
+}
+
+export function WhyPanel({ executedRules, open, onToggle }: WhyPanelProps) {
+    const matched = executedRules.filter(r => r.matched);
+    const skipped = executedRules.filter(r => !r.matched);
+
+    return (
+        <div className="border-t border-[color:var(--line)] bg-[color:var(--panel)] shrink-0">
+            <button
+                type="button"
+                onClick={onToggle}
+                className="w-full px-6 h-10 flex items-center gap-2 text-left hover:bg-[color:var(--panel-2)]"
+            >
+                <span className="caps text-[color:var(--muted)]">Warum diese Teile?</span>
+                <span className="mono text-[10px] text-[color:var(--muted-2)]">{matched.length} Regeln angewendet</span>
+                <span className="ml-auto mono text-[11px] text-[color:var(--muted)]">{open ? '−' : '+'}</span>
+            </button>
+            {open && (
+                <div className="px-6 pb-4 max-h-[180px] overflow-y-auto scroll-slim">
+                    <div className="grid grid-cols-2 gap-4">
+                        <div>
+                            <div className="caps text-[color:var(--muted-2)] mb-2">Angewendet</div>
+                            <div className="space-y-1">
+                                {matched.length === 0 && <div className="mono text-[11px] text-[color:var(--muted-2)]">— keine —</div>}
+                                {matched.map(r => (
+                                    <div key={r.ruleId} className="flex items-start gap-2">
+                                        <span className="mono text-[10px] text-[#a3e635] mt-0.5">●</span>
+                                        <div className="flex-1 min-w-0">
+                                            <div className="mono text-[11px] text-[color:var(--ink)]">{r.ruleName}</div>
+                                            <div className="mono text-[10px] text-[color:var(--muted-2)]">{r.phaseKey}</div>
+                                        </div>
+                                    </div>
+                                ))}
+                            </div>
+                        </div>
+                        <div>
+                            <div className="caps text-[color:var(--muted-2)] mb-2">Übersprungen</div>
+                            <div className="space-y-1">
+                                {skipped.length === 0 && <div className="mono text-[11px] text-[color:var(--muted-2)]">— keine —</div>}
+                                {skipped.map(r => (
+                                    <div key={r.ruleId} className="flex items-start gap-2">
+                                        <span className="mono text-[10px] text-[color:var(--muted-2)] mt-0.5">○</span>
+                                        <div className="flex-1 min-w-0">
+                                            <div className="mono text-[11px] text-[color:var(--muted)]">{r.ruleName}</div>
+                                            {r.skipReason && (
+                                                <div className="mono text-[10px] text-[color:var(--muted-2)]">{r.skipReason}</div>
+                                            )}
+                                        </div>
+                                    </div>
+                                ))}
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            )}
+        </div>
+    );
+}

package/dist/assets/storefront/src/scenarios/kaminpro/pdp/configurator-pdp.tsx

@@ -0,0 +1,43 @@
+import type { PdpPageProps } from '@/config/scenario';
+import {
+    addConfigurationToOrder,
+    evaluateConfiguration,
+} from '@/app/[locale]/(catalog)/product/[slug]/actions';
+import { AuthGate } from '../auth-gate';
+import { ConfiguratorShell } from './configurator-shell';
+
+/**
+ * KaminPro configurator PDP — scenario-level full-page override.
+ *
+ * Only engages for configurable products (gated by `shouldApply` in the
+ * scenario config). Unauthenticated visitors hit the shared `AuthGate`
+ * which renders the LoginNotice; authenticated partners see the three-
+ * column configurator shell driven by the live `ConfiguratorSystem`
+ * fetched in the host `page.tsx`.
+ *
+ * The host page.tsx is responsible for rendering the breadcrumb row; this
+ * override only contributes the main content area.
+ */
+export async function KaminProConfiguratorPdp({ product, configuratorSystem }: PdpPageProps) {
+    // Belt-and-braces — the `shouldApply` predicate on the scenario override
+    // means we should never reach this override without a system. Fall back
+    // gracefully rather than crashing.
+    if (!configuratorSystem) {
+        return (
+            <div className="container mx-auto px-4 py-12 text-sm text-muted-foreground">
+                Konfigurator nicht verfügbar.
+            </div>
+        );
+    }
+
+    return (
+        <AuthGate>
+            <ConfiguratorShell
+                system={configuratorSystem}
+                initialConfigName={`Konfiguration — ${product.name}`}
+                evaluateAction={evaluateConfiguration}
+                addToOrderAction={addConfigurationToOrder}
+            />
+        </AuthGate>
+    );
+}

package/dist/assets/storefront/src/scenarios/kaminpro/pdp/configurator-shell.tsx

@@ -0,0 +1,320 @@
+'use client';
+
+import { cn } from '@/lib/utils';
+import { useRouter } from '@/i18n/navigation';
+import { isRedirectError } from 'next/dist/client/components/redirect-error';
+import { toast } from 'sonner';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { requestQuoteWithItems } from '@/app/[locale]/account/quotes/actions';
+import './styles.css';
+
+import { buildFieldRef, fmtEuro } from './lib/data';
+import type {
+    ConfigurationEvaluation,
+    ConfiguratorSystem,
+    Values,
+} from './lib/types';
+
+import { BomBasket, type CtaAction } from './components/bom-basket';
+import { WarnBanner } from './components/banners';
+import { Chip } from './components/chip';
+import { ConfigHeader } from './components/config-header';
+import { ModulePanel } from './components/module-panel';
+import { QuoteDialog } from './components/quote-dialog';
+import { Schematic } from './components/schematic';
+import { WhyPanel } from './components/why-panel';
+
+type EvaluateAction = (
+    systemId: string,
+    values: { fieldRef: string; value: string }[],
+) => Promise<{ data?: ConfigurationEvaluation; error?: string }>;
+
+type AddToOrderAction = (
+    systemId: string,
+    values: { fieldRef: string; value: string }[],
+    name?: string,
+) => Promise<{ success: boolean; error?: string }>;
+
+interface ConfiguratorShellProps {
+    system: ConfiguratorSystem;
+    initialConfigName?: string;
+    evaluateAction: EvaluateAction;
+    addToOrderAction: AddToOrderAction;
+}
+
+export function ConfiguratorShell({
+    system,
+    initialConfigName = 'Neue Konfiguration',
+    evaluateAction,
+    addToOrderAction,
+}: ConfiguratorShellProps) {
+    // Seed values from the backend field defaults so the first-render state
+    // is complete and the schematic/BOM populate immediately.
+    const [values, setValues] = useState<Values>(() => {
+        const initial: Values = {};
+        for (const mod of system.modules) {
+            for (const field of mod.fields) {
+                if (field.defaultValue) {
+                    initial[buildFieldRef(mod.code, field.code)] = field.defaultValue;
+                }
+            }
+        }
+        return initial;
+    });
+
+    const [configName, setConfigName] = useState(initialConfigName);
+    const [activeModuleId, setActiveModuleId] = useState(system.modules[0]?.code ?? '');
+    const [whyOpen, setWhyOpen] = useState(false);
+    const [warnDismissed, setWarnDismissed] = useState(false);
+    // Collapsible module panel — when collapsed the schematic column claims
+    // the freed width and the SVG scales up proportionally (meet-fit).
+    const [panelCollapsed, setPanelCollapsed] = useState(false);
+
+    const [evaluation, setEvaluation] = useState<ConfigurationEvaluation | null>(null);
+    const [isEvaluating, setIsEvaluating] = useState(false);
+    const [cartState, setCartState] = useState<'idle' | 'adding' | 'added'>('idle');
+    const [quoteState, setQuoteState] = useState<'idle' | 'saving'>('idle');
+    const [quoteDialogOpen, setQuoteDialogOpen] = useState(false);
+    const evalTimer = useRef<ReturnType<typeof setTimeout>>(undefined);
+    const router = useRouter();
+
+    const fieldValueEntries = useCallback(() => {
+        return Object.entries(values)
+            .filter(([, v]) => v !== '')
+            .map(([fieldRef, value]) => ({ fieldRef, value }));
+    }, [values]);
+
+    // 300ms debounced evaluate — mirrors the generic ConfiguratorForm pattern.
+    useEffect(() => {
+        clearTimeout(evalTimer.current);
+        evalTimer.current = setTimeout(async () => {
+            const entries = fieldValueEntries();
+            if (entries.length === 0) return;
+            setIsEvaluating(true);
+            const result = await evaluateAction(system.id, entries);
+            setIsEvaluating(false);
+            if (result.data) setEvaluation(result.data);
+            if (result.error) toast.error(result.error);
+        }, 300);
+        return () => clearTimeout(evalTimer.current);
+    }, [values, system.id, evaluateAction, fieldValueEntries]);
+
+    const handleFieldChange = (moduleCode: string, fieldCode: string, value: string) => {
+        setValues(prev => ({ ...prev, [buildFieldRef(moduleCode, fieldCode)]: value }));
+    };
+
+    // Aggregate errors: system-level + per-field error messages.
+    const { errorCount, warnCount, allErrors } = useMemo(() => {
+        const sys = evaluation?.errors ?? [];
+        const fieldIssues: { fieldName: string; message: string; type: string }[] = [];
+        for (const mod of system.modules) {
+            for (const field of mod.fields) {
+                const ref = buildFieldRef(mod.code, field.code);
+                const ef = evaluation?.fields.find(f => f.fieldRef === ref);
+                if (ef?.hidden) continue;
+                for (const msg of ef?.messages ?? []) {
+                    if (msg.type === 'error' || msg.type === 'warning') {
+                        fieldIssues.push({ fieldName: field.name, message: msg.message, type: msg.type });
+                    }
+                }
+            }
+        }
+        const errs = [...sys.map(e => e.message), ...fieldIssues.filter(i => i.type === 'error').map(i => `${i.fieldName}: ${i.message}`)];
+        return {
+            errorCount: errs.length,
+            warnCount: fieldIssues.filter(i => i.type === 'warning').length,
+            allErrors: errs,
+        };
+    }, [evaluation, system.modules]);
+
+    const lines = evaluation?.lines ?? [];
+
+    const handleCta = async (action: CtaAction) => {
+        if (action === 'cart') {
+            setCartState('adding');
+            const entries = fieldValueEntries();
+            const result = await addToOrderAction(system.id, entries, configName);
+            if (result.success) {
+                const total = lines.reduce(
+                    (s, l) => s + l.productVariant.priceWithTax * l.quantity,
+                    0,
+                ) / 100;
+                setCartState('added');
+                toast.success('In den Warenkorb gelegt', {
+                    description: `${configName} · ${evaluation?.totals.lineCount ?? 0} Positionen · ${fmtEuro(total)}`,
+                    duration: 6000,
+                    action: {
+                        label: 'Zur Kasse',
+                        onClick: () => router.push('/checkout'),
+                    },
+                });
+                // Refresh server components so the nav cart-count updates
+                // immediately, and reset the CTA back to idle after the
+                // user has had time to see the confirmation.
+                router.refresh();
+                window.setTimeout(() => setCartState('idle'), 2500);
+            } else {
+                setCartState('idle');
+                toast.error(result.error || 'Konnte Konfiguration nicht in den Warenkorb legen');
+            }
+        } else if (action === 'quote') {
+            if (lines.length === 0) return;
+            setQuoteDialogOpen(true);
+        }
+    };
+
+    const handleQuoteSubmit = async (userMessage: string) => {
+        if (lines.length === 0) return;
+        setQuoteState('saving');
+        // Each evaluated BOM line becomes a quote line item. The note
+        // combines the configuration name (for the /account/quotes list
+        // view) with the partner's free-text message (their discount
+        // request, liefertermin, etc.) so the account manager sees both.
+        const lineItems = lines.map(l => ({
+            productVariantId: l.productVariant.id,
+            quantity: l.quantity,
+        }));
+        const note = userMessage
+            ? `${configName}\n\n${userMessage}`
+            : configName;
+        try {
+            const result = await requestQuoteWithItems(lineItems, note);
+            // Reached only on failure — success path redirects to
+            // /account/quotes/<id> and never returns.
+            if (result && !result.success) {
+                setQuoteState('idle');
+                toast.error(result.message || 'Konnte Angebot nicht speichern');
+            }
+        } catch (err) {
+            if (isRedirectError(err)) throw err;
+            setQuoteState('idle');
+            toast.error('Konnte Angebot nicht speichern');
+        }
+    };
+
+    const totalPriceCents = lines.reduce(
+        (s, l) => s + l.productVariant.priceWithTax * l.quantity,
+        0,
+    );
+
+    const rightChip = (
+        <>
+            {errorCount > 0 && <Chip tone="err">{errorCount} Fehler</Chip>}
+            {warnCount > 0 && <Chip tone="warn">{warnCount} Warnung</Chip>}
+            {isEvaluating ? (
+                <span className="mono text-[10.5px] text-[color:var(--muted)] flex items-center gap-1.5">
+                    <span className="w-1.5 h-1.5 rounded-full bg-[color:var(--fire)] pulse-dot" />
+                    Berechne…
+                </span>
+            ) : (
+                <span className="mono text-[10.5px] text-[color:var(--muted-2)]">Aktualisiert · gerade eben</span>
+            )}
+        </>
+    );
+
+    return (
+        <div className="kp-pdp flex-1 h-[calc(100vh-var(--page-top-offset)-90px)] flex flex-col overflow-hidden">
+            <ConfigHeader
+                systemName={system.name}
+                systemSub={system.description ?? ''}
+                configName={configName}
+                onRename={setConfigName}
+                rightChip={rightChip}
+            />
+
+            {warnCount > 0 && !warnDismissed && (
+                <WarnBanner count={warnCount} onDismiss={() => setWarnDismissed(true)} />
+            )}
+
+            {allErrors.length > 0 && (
+                <div className="px-6 py-2 bg-[#2a0a0a] border-b border-[#4a1818] flex flex-col gap-1">
+                    {allErrors.map(err => (
+                        <div key={err} className="text-[12px] text-[#fca5a5]">
+                            <span className="mono text-[10px] px-1.5 py-0.5 rounded-sm bg-[#4a1818] text-[#fecaca] uppercase tracking-wider mr-2">
+                                Fehler
+                            </span>
+                            {err}
+                        </div>
+                    ))}
+                </div>
+            )}
+
+            <div
+                className={cn(
+                    'flex-1 min-h-0 grid',
+                    'grid-cols-1',
+                    panelCollapsed
+                        ? 'lg:grid-cols-[56px_minmax(0,1fr)_380px]'
+                        : 'lg:grid-cols-[270px_minmax(0,1fr)_380px]',
+                )}
+            >
+                {/* LEFT — module panel */}
+                <aside className="border-b lg:border-b-0 lg:border-r border-[color:var(--line)] overflow-hidden">
+                    <ModulePanel
+                        system={system}
+                        values={values}
+                        evaluation={evaluation}
+                        activeId={activeModuleId}
+                        collapsed={panelCollapsed}
+                        onActivate={code => {
+                            setActiveModuleId(code);
+                            // Auto-expand when the user picks a module from
+                            // the rail — collapsed-rail clicks expect to
+                            // reveal field rows, not stay minimized.
+                            if (panelCollapsed) setPanelCollapsed(false);
+                        }}
+                        onToggleCollapsed={() => setPanelCollapsed(v => !v)}
+                        onChange={handleFieldChange}
+                    />
+                </aside>
+
+                {/* CENTER — schematic + why */}
+                <section className="flex flex-col min-h-[520px] overflow-hidden">
+                    <div className="flex-1 min-h-[520px] paper-bg relative overflow-hidden">
+                        <Schematic system={system} evaluation={evaluation} />
+
+                        <div className="absolute left-4 bottom-4 mono text-[10px] text-[color:var(--muted-2)] flex items-center gap-3">
+                            <span>SCHEMA · AUTOMATISCH GENERIERT</span>
+                            <span className="w-px h-3 bg-[color:var(--line)]" />
+                            <span>{evaluation?.totals.lineCount ?? 0} Positionen</span>
+                            <span className="w-px h-3 bg-[color:var(--line)]" />
+                            <span>{evaluation?.totals.totalQuantity ?? 0} Teile</span>
+                        </div>
+                    </div>
+
+                    <WhyPanel
+                        executedRules={evaluation?.executedRules ?? []}
+                        open={whyOpen}
+                        onToggle={() => setWhyOpen(v => !v)}
+                    />
+                </section>
+
+                {/* RIGHT — BOM */}
+                <aside className="border-t lg:border-t-0 lg:border-l border-[color:var(--line)] overflow-hidden">
+                    <BomBasket
+                        evaluation={evaluation}
+                        hasErrors={errorCount > 0}
+                        cartState={cartState}
+                        quoteState={quoteState}
+                        onCta={handleCta}
+                    />
+                </aside>
+            </div>
+
+            <QuoteDialog
+                open={quoteDialogOpen}
+                onOpenChange={open => {
+                    // Don't allow closing while the submit is in flight —
+                    // the redirect will move the user away on success.
+                    if (quoteState === 'saving' && !open) return;
+                    setQuoteDialogOpen(open);
+                }}
+                configName={configName}
+                lineCount={evaluation?.totals.lineCount ?? 0}
+                totalPriceCents={totalPriceCents}
+                submitting={quoteState === 'saving'}
+                onSubmit={handleQuoteSubmit}
+            />
+        </div>
+    );
+}

package/dist/assets/storefront/src/scenarios/kaminpro/pdp/lib/data.ts

@@ -0,0 +1,150 @@
+/**
+ * KaminPro configurator — chrome utilities.
+ *
+ * The system definition, catalogue, and rule engine all live in the backend
+ * (`libs/scenario-kaminpro/src/configurator-data.ts` +
+ * `@vendure-platform/configurator` plugin). This module only carries the small
+ * frontend-owned affordances: currency formatting, classification ordering
+ * for the BOM groups, and the `buildFieldRef` helper.
+ */
+import type {
+    ConfiguratorField,
+    ConfiguratorModule,
+    ConfigurationEvaluation,
+    EvaluatedLine,
+    Values,
+} from './types';
+
+/**
+ * Build the `"moduleCode.fieldCode"` ref the backend expects as input and
+ * returns as keys in its evaluation output. Mirrors
+ * `apps/storefront/src/components/commerce/configurator-form.tsx:32` — keep
+ * them aligned so the two configurator PDPs speak the same dialect.
+ */
+export const buildFieldRef = (moduleCode: string, fieldCode: string): string =>
+    `${moduleCode}.${fieldCode}`;
+
+/**
+ * Canonical BOM grouping order. The backend catalogue tags every part with a
+ * `classification` facet value; this array gives the chrome its render order.
+ *
+ * Unknown/missing classifications bucket into `"Sonstiges"` and render last —
+ * adding a new classification facet value to the catalogue is safe and just
+ * appears at the end until this list is updated.
+ */
+export const CLASSIFICATION_ORDER: string[] = [
+    'tConnector',        // T-Stück — the install anchor
+    'baseParts',         // Fußteil
+    'Rohrstück',         // main stack
+    'wallBracket',       // Wandkonsole
+    'roofDuct',          // Dachdurchführung
+    'rainHood',          // Regenhaube
+    'outflowCone',       // Abstromkonus
+    'bracingSetThreePoint', // 3-point bracing
+    'gasket',            // Dichtung
+];
+
+export const CLASSIFICATION_FALLBACK = 'Sonstiges';
+
+/**
+ * Read the `classification` facet value off an evaluated BOM line. Returns
+ * `CLASSIFICATION_FALLBACK` if none present so the UI never produces an
+ * empty group heading.
+ */
+export function getLineClassification(line: EvaluatedLine): string {
+    const facetValues = line.productVariant?.facetValues ?? [];
+    const match = facetValues.find(fv => fv.facet?.code === 'classification');
+    return match?.code ?? CLASSIFICATION_FALLBACK;
+}
+
+/**
+ * Human-readable label for a classification code. German-first; unknowns
+ * pass through verbatim so new codes in the catalogue don't break the UI.
+ */
+const CLASSIFICATION_LABELS: Record<string, string> = {
+    tConnector: 'T-Stück',
+    baseParts: 'Fußteil',
+    Rohrstück: 'Rohrstück',
+    wallBracket: 'Wandkonsole',
+    roofDuct: 'Dachdurchführung',
+    rainHood: 'Regenhaube',
+    outflowCone: 'Abstromkonus',
+    bracingSetThreePoint: 'Abspannung',
+    gasket: 'Dichtung',
+    [CLASSIFICATION_FALLBACK]: 'Sonstiges',
+};
+
+export function classificationLabel(code: string): string {
+    return CLASSIFICATION_LABELS[code] ?? code;
+}
+
+/** Currency formatter pinned to de-AT / EUR — KaminPro is single-market. */
+export function fmtEuro(n: number | null | undefined): string {
+    return new Intl.NumberFormat('de-AT', {
+        style: 'currency',
+        currency: 'EUR',
+        minimumFractionDigits: 2,
+    }).format(n ?? 0);
+}
+
+/**
+ * Resolve an option label from a backend field definition. Used by the
+ * schematic for annotations (e.g. "Regenhaube"). Falls back to the raw
+ * value when no matching option exists (numeric fields, or values that
+ * were narrowed out of options by a constrain rule).
+ */
+export function labelForOption(field: ConfiguratorField | undefined, value: string | undefined): string {
+    if (!value) return '';
+    const opt = field?.options?.find(o => o.code === value);
+    return opt?.label ?? value;
+}
+
+export function moduleStats(
+    mod: ConfiguratorModule,
+    values: Values,
+    evaluation: ConfigurationEvaluation | null,
+): { total: number; filled: number; invalid: number } {
+    let total = 0;
+    let filled = 0;
+    let invalid = 0;
+    for (const f of mod.fields) {
+        const ref = buildFieldRef(mod.code, f.code);
+        const evalField = evaluation?.fields.find(ef => ef.fieldRef === ref);
+        if (evalField?.hidden) continue;
+        total++;
+        const v = values[ref];
+        if (v !== undefined && v !== '') filled++;
+        if (evalField?.messages.some(m => m.type === 'error')) invalid++;
+    }
+    return { total, filled, invalid };
+}
+
+/**
+ * Find the backend's field definition for a given `moduleCode.fieldCode`
+ * ref. Returns `undefined` when the field has been removed from the
+ * backend schema — consumers (notably the schematic) should treat
+ * `undefined` as "render the neutral default".
+ */
+export function getFieldDefinition(
+    system: { modules: ConfiguratorModule[] },
+    ref: string,
+): ConfiguratorField | undefined {
+    const [moduleCode, fieldCode] = ref.split('.');
+    if (!moduleCode || !fieldCode) return undefined;
+    const mod = system.modules.find(m => m.code === moduleCode);
+    return mod?.fields.find(f => f.code === fieldCode);
+}
+
+/**
+ * Read a field's current evaluated value from the ConfigurationEvaluation.
+ * Returns `fallback` when the field isn't present in the evaluation —
+ * makes UI consumers (particularly the schematic) resilient to backend
+ * config changes.
+ */
+export function getEvaluatedValue(
+    evaluation: ConfigurationEvaluation | null,
+    ref: string,
+    fallback = '',
+): string {
+    return evaluation?.fields.find(f => f.fieldRef === ref)?.value ?? fallback;
+}

package/dist/assets/storefront/src/scenarios/kaminpro/pdp/lib/types.ts

@@ -0,0 +1,30 @@
+/**
+ * KaminPro configurator — domain types.
+ *
+ * Re-exported from gql.tada so the specialized PDP is driven by the same
+ * shapes the backend `@vendure-platform/configurator` plugin returns. This keeps
+ * the chrome thin and the backend authoritative — a new field, option or
+ * rule appears in the UI without a frontend code change.
+ *
+ * The only exception is the technical schematic SVG
+ * (`components/schematic.tsx`), which reads specific `moduleCode.fieldCode`
+ * refs to drive geometry. That coupling is documented at the top of the
+ * schematic file.
+ */
+
+export type {
+    ConfiguratorSystem,
+    ConfiguratorModule,
+    ConfiguratorField,
+    ConfigurationEvaluation,
+    EvaluatedField,
+    EvaluatedLine,
+    EvaluatedExecutedRule,
+} from '@/lib/vendure/queries';
+
+/**
+ * Configurator values keyed by `${moduleCode}.${fieldCode}` — matches the
+ * input shape for `evaluateProductConfiguration` and the `fieldRef` keys the
+ * backend returns on evaluation results.
+ */
+export type Values = Record<string, string>;