meno-core 1.0.53 → 1.1.0

package/lib/server/webflow/buildWebflow.ts

@@ -1,635 +0,0 @@
-/**
- * Webflow Export Build Orchestrator
- * Loads the project, renders all pages, and converts to Webflow payload.
- * Mirrors the pattern of build-astro.ts.
- */
-
-import { existsSync, readdirSync } from 'fs';
-import { readFile } from 'fs/promises';
-import { join } from 'path';
-import {
-  loadJSONFile,
-  loadComponentDirectory,
-  mapPageNameToPath,
-  parseJSON,
-  loadI18nConfig,
-  loadBreakpointConfig,
-} from '../jsonLoader';
-import { renderPageSSR } from '../ssr/ssrRenderer';
-import { projectPaths } from '../projectContext';
-import { loadProjectConfig } from '../../shared/fontLoader';
-import { FileSystemCMSProvider } from '../providers/fileSystemCMSProvider';
-import { CMSService } from '../services/cmsService';
-import { isI18nValue, resolveI18nValue } from '../../shared/i18n';
-import { RAW_HTML_PREFIX } from '../../shared/constants';
-import { extractPageMeta, type PageMeta } from '../ssr/metaTagGenerator';
-import { configService } from '../services/configService';
-import { colorService } from '../services/ColorService';
-import { variableService } from '../services/VariableService';
-import { migrateTemplatesDirectory } from '../migrateTemplates';
-import type {
-  ComponentDefinition,
-  JSONPage,
-  CMSSchema,
-  CMSItem,
-  I18nConfig,
-  ThemeConfig,
-} from '../../shared/types';
-import { resolvePaletteColor } from '../../shared/types/colors';
-import type { SlugMap } from '../../shared/slugTranslator';
-import type {
-  WebflowExportPayload,
-  WebflowPage,
-  WebflowStyleClass,
-  WebflowAssetRef,
-  WebflowScript,
-  WebflowComponentDef,
-} from './types';
-import { nodeToWebflow, normalizeListChildren, type WebflowEmitContext } from './nodeToWebflow';
-import { isWebflowHandledRule } from './styleMapper';
-import { generateInteractiveCSS } from '../../shared/cssGeneration';
-import { generateVariablesCSS } from '../cssGenerator';
-import type { InteractiveStyles } from '../../shared/types/styles';
-import { resolveVariableValueAtBreakpoint } from '../../shared/responsiveScaling';
-import type { ResponsiveScales } from '../../shared/responsiveScaling';
-import type { VariablesConfig } from '../../shared/types';
-import type { BreakpointConfig } from '../../shared/breakpoints';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function scanJSONFiles(dir: string, prefix: string = ''): string[] {
-  const results: string[] = [];
-  if (!existsSync(dir)) return results;
-  const entries = readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isFile() && entry.name.endsWith('.json')) {
-      results.push(prefix ? `${prefix}/${entry.name}` : entry.name);
-    } else if (entry.isDirectory()) {
-      results.push(...scanJSONFiles(join(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name));
-    }
-  }
-  return results;
-}
-
-function isCMSPage(pageData: JSONPage): boolean {
-  return pageData.meta?.source === 'cms' && !!pageData.meta?.cms;
-}
-
-/**
- * Flatten a CMS item for the Webflow emit path: resolve i18n values to the
- * current locale and unwrap rich-text markers (`{ __richtext__, html }`) into
- * `RAW_HTML_PREFIX + html` so `nodeToWebflow`'s `resolveTemplate` can flatten
- * inline HTML to plain text. Mirrors what SSR's `processCMSTemplate`
- * (`cmsSSRProcessor.ts`) does inline at every interpolation site — but applied
- * once up front so the simpler Webflow `resolveTemplate` (which only does
- * `String(value)`) renders meaningful text instead of `[object Object]` /
- * empty strings.
- */
-function flattenCMSItemForLocale(
-  item: CMSItem,
-  locale: string,
-  i18nConfig: I18nConfig
-): Record<string, unknown> {
-  const flatten = (value: unknown): unknown => {
-    if (value === null || value === undefined) return value;
-    if (isI18nValue(value)) {
-      return flatten(resolveI18nValue(value, locale, i18nConfig));
-    }
-    if (typeof value === 'object' && '__richtext__' in (value as object)) {
-      const html = (value as { html?: unknown }).html;
-      if (typeof html === 'string') return RAW_HTML_PREFIX + html;
-    }
-    return value;
-  };
-  const out: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(item)) {
-    out[key] = flatten(value);
-  }
-  return out;
-}
-
-/**
- * Resolve a page-meta value (which may be an i18n object) to a string for the
- * given locale, or undefined when the field is empty.
- */
-function resolveMetaString(
-  value: unknown,
-  locale: string,
-  i18nConfig: I18nConfig
-): string | undefined {
-  if (value === undefined || value === null || value === '') return undefined;
-  const resolved = isI18nValue(value)
-    ? resolveI18nValue(value, locale, i18nConfig)
-    : value;
-  if (resolved === undefined || resolved === null || resolved === '') return undefined;
-  return String(resolved);
-}
-
-/**
- * Lift the structured meta from a page (title, description, OG fields,
- * keywords) into the per-locale fields of a `WebflowPage`. SSR's `result.title`
- * is preserved as the canonical title; the rest comes from `extractPageMeta`.
- */
-function buildPageMetaForLocale(
-  meta: PageMeta,
-  locale: string,
-  i18nConfig: I18nConfig
-): Pick<WebflowPage, 'description' | 'keywords' | 'ogTitle' | 'ogDescription' | 'ogImage'> {
-  return {
-    description: resolveMetaString(meta.description, locale, i18nConfig),
-    keywords: resolveMetaString(meta.keywords, locale, i18nConfig),
-    ogTitle: resolveMetaString(meta.ogTitle, locale, i18nConfig),
-    ogDescription: resolveMetaString(meta.ogDescription, locale, i18nConfig),
-    ogImage: resolveMetaString(meta.ogImage, locale, i18nConfig),
-  };
-}
-
-function scanAssets(projectRoot: string): WebflowAssetRef[] {
-  const assets: WebflowAssetRef[] = [];
-  const assetDirs: Array<{ dir: string; type: WebflowAssetRef['type'] }> = [
-    { dir: 'images', type: 'image' },
-    { dir: 'fonts', type: 'font' },
-    { dir: 'videos', type: 'video' },
-    { dir: 'assets', type: 'file' },
-  ];
-
-  for (const { dir, type } of assetDirs) {
-    const fullDir = join(projectRoot, dir);
-    if (!existsSync(fullDir)) continue;
-    const files = scanJSONFiles(fullDir).map(f => f.replace('.json', '')); // scanJSONFiles works for any extension
-    // Re-scan properly for all file types
-    const allFiles = scanAllFiles(fullDir);
-    for (const file of allFiles) {
-      assets.push({
-        localPath: `${dir}/${file}`,
-        type,
-        fileName: file.split('/').pop()!,
-      });
-    }
-  }
-
-  return assets;
-}
-
-function scanAllFiles(dir: string, prefix: string = ''): string[] {
-  const results: string[] = [];
-  if (!existsSync(dir)) return results;
-  const entries = readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isFile()) {
-      results.push(relativePath);
-    } else if (entry.isDirectory()) {
-      results.push(...scanAllFiles(join(dir, entry.name), relativePath));
-    }
-  }
-  return results;
-}
-
-/**
- * Build per-theme `--var` maps so the walker can resolve `var(--bg)` against
- * whatever theme an element actually inherits. Each theme key holds its full
- * resolved palette (text, bg, border, …); `defaultThemeName` is what we fall
- * back to when an element has no `theme` ancestor.
- */
-function buildThemeVarMaps(
-  themeConfig: ThemeConfig
-): { byTheme: Record<string, Record<string, string>>; defaultTheme: string } {
-  const palette = themeConfig.palette;
-  const byTheme: Record<string, Record<string, string>> = {};
-  for (const [themeName, theme] of Object.entries(themeConfig.themes)) {
-    const vars: Record<string, string> = {};
-    for (const [name, value] of Object.entries(theme.colors)) {
-      vars[`--${name}`] = resolvePaletteColor(value, palette);
-    }
-    byTheme[themeName] = vars;
-  }
-  return { byTheme, defaultTheme: themeConfig.default };
-}
-
-/**
- * Build a per-breakpoint `--var → value` map directly from the variables
- * config. Each breakpoint key (`base`, `tablet`, `mobile`, …) holds the full
- * resolved variable map at that breakpoint, with per-variable `scales`
- * overrides and global category scaling already applied
- * (`resolveVariableValueAtBreakpoint` mirrors `generateVariablesCSS` and the
- * runtime CSS resolver).
- *
- * The walker uses these maps to inline `var(--x)` references in element
- * styles per-breakpoint, so the Webflow class system receives concrete
- * scaled values at every tier instead of a single flat base value.
- */
-function buildProjectVarMaps(
-  variablesConfig: VariablesConfig,
-  breakpoints: BreakpointConfig,
-  responsiveScales: ResponsiveScales | undefined
-): Record<string, Record<string, string>> {
-  const out: Record<string, Record<string, string>> = { base: {} };
-  for (const bpName of Object.keys(breakpoints)) out[bpName] = {};
-
-  for (const variable of variablesConfig.variables) {
-    if (!variable.cssVar) continue;
-    out.base[variable.cssVar] = variable.value;
-    for (const bpName of Object.keys(breakpoints)) {
-      const resolved = resolveVariableValueAtBreakpoint(
-        { value: variable.value, type: variable.type, scales: variable.scales },
-        bpName,
-        responsiveScales
-      );
-      out[bpName][variable.cssVar] = resolved;
-    }
-  }
-  return out;
-}
-
-// ---------------------------------------------------------------------------
-// Main export
-// ---------------------------------------------------------------------------
-
-export async function buildWebflowPayload(
-  options?: { bindCollectionLists?: boolean; promotedComponentNames?: string[]; locale?: string }
-): Promise<WebflowExportPayload> {
-  const bindCollectionLists = options?.bindCollectionLists === true;
-  const promotedComponentNames = Array.isArray(options?.promotedComponentNames)
-    ? new Set(options!.promotedComponentNames.filter((n): n is string => typeof n === 'string' && n.length > 0))
-    : undefined;
-  // 1. Setup: load project configuration
-  configService.reset();
-
-  const projectConfig = await loadProjectConfig();
-  const siteUrl = (projectConfig as { siteUrl?: string }).siteUrl?.replace(/\/$/, '') || '';
-  const i18nConfig = await loadI18nConfig();
-
-  // Pick which locale to render. Multi-locale projects export one locale at a
-  // time so the Webflow site mirrors a single language; the extension surfaces
-  // a picker that defaults to `i18nConfig.defaultLocale`. An invalid/missing
-  // request falls back to the default locale (silent — the picker is the
-  // source of truth here, not the URL).
-  const requestedLocale = options?.locale;
-  const selectedLocale = (requestedLocale && i18nConfig.locales.some(l => l.code === requestedLocale))
-    ? requestedLocale
-    : i18nConfig.defaultLocale;
-  const localesToBuild = i18nConfig.locales.filter(l => l.code === selectedLocale);
-
-  await migrateTemplatesDirectory();
-
-  const { components } = await loadComponentDirectory(projectPaths.components());
-  const globalComponents: Record<string, ComponentDefinition> = {};
-  components.forEach((value, key) => { globalComponents[key] = value; });
-
-  const cmsProvider = new FileSystemCMSProvider(projectPaths.templates(), projectPaths.cms());
-  const cmsService = new CMSService(cmsProvider);
-  await cmsService.initialize();
-
-  const themeConfig = await colorService.loadThemeConfig();
-  const variablesConfig = await variableService.loadConfig();
-  const breakpoints = await loadBreakpointConfig();
-
-  await configService.load();
-  const responsiveScales = configService.getResponsiveScales();
-
-  // 2. Scan pages
-  const pagesDir = projectPaths.pages();
-  if (!existsSync(pagesDir)) {
-    return emptyPayload();
-  }
-
-  const pageFiles = scanJSONFiles(pagesDir);
-  if (pageFiles.length === 0) {
-    return emptyPayload();
-  }
-
-  // Collect slug mappings
-  const slugMappings: SlugMap[] = [];
-  for (const file of pageFiles) {
-    const pageName = file.replace('.json', '');
-    const basePath = mapPageNameToPath(pageName);
-    const pageContent = await loadJSONFile(join(pagesDir, file));
-    if (!pageContent) continue;
-    try {
-      const pageData = parseJSON<JSONPage>(pageContent);
-      if (pageData.meta?.slugs) {
-        const pageId = basePath === '/' ? 'index' : basePath.substring(1);
-        slugMappings.push({ pageId, slugs: pageData.meta.slugs });
-      }
-    } catch { /* ignore */ }
-  }
-
-  // 3. Render and convert pages
-  const allPages: WebflowPage[] = [];
-  const allStyleClasses = new Map<string, WebflowStyleClass>();
-  // elementClass → interactiveStyles, populated during the node walk and
-  // drained at the end into raw CSS (see step 6 below).
-  const allInteractiveStylesMap = new Map<string, InteractiveStyles>();
-  // Combo class name → owning identity, shared across every page emit so
-  // collisions are visible project-wide. Drives `mintInstanceComboName` in
-  // nodeToWebflow.ts.
-  const allComboIdentityByName = new Map<string, string>();
-  // First-encounter snapshot of each promoted component (Navigation, Footer)
-  // shared across every page so the extension registers each definition once.
-  const promotedComponents = new Map<string, WebflowComponentDef>();
-
-  // Theme + project-level CSS variables are resolved during the walk so the
-  // ancestor `theme` attribute can pick the right palette per element. The
-  // project var map is per-breakpoint so `var(--x)` refs in element styles
-  // can be inlined at each tier with the right scaled value.
-  const variablesCSS = generateVariablesCSS(variablesConfig, breakpoints, responsiveScales);
-  const projectVars = buildProjectVarMaps(variablesConfig, breakpoints, responsiveScales);
-  const { byTheme: themeVars, defaultTheme } = buildThemeVarMaps(themeConfig);
-
-  // Regular pages
-  for (const file of pageFiles) {
-    const pageName = file.replace('.json', '');
-    const basePath = mapPageNameToPath(pageName);
-    const pageContent = await loadJSONFile(join(pagesDir, file));
-    if (!pageContent) continue;
-
-    try {
-      const pageData = parseJSON<JSONPage>(pageContent);
-      if (pageData.meta?.draft === true) continue;
-
-      const slugs = pageData.meta?.slugs;
-
-      for (const localeConfig of localesToBuild) {
-        const locale = localeConfig.code;
-        const isDefault = locale === i18nConfig.defaultLocale;
-
-        let slug: string;
-        if (slugs && slugs[locale]) {
-          slug = slugs[locale];
-        } else if (basePath === '/') {
-          slug = '';
-        } else {
-          slug = basePath.substring(1);
-        }
-
-        const urlPath = isDefault
-          ? (slug === '' ? '/' : `/${slug}`)
-          : (slug === '' ? `/${locale}` : `/${locale}/${slug}`);
-
-        // Render via SSR to resolve all props
-        const result = await renderPageSSR(
-          pageData,
-          globalComponents,
-          urlPath,
-          siteUrl,
-          locale,
-          i18nConfig,
-          slugMappings,
-          undefined,
-          cmsService,
-          true
-        );
-
-        // Convert node tree to Webflow elements
-        const ctx: WebflowEmitContext = {
-          globalComponents,
-          elementPath: [0],
-          fileType: 'page',
-          fileName: pageName,
-          breakpoints,
-          styleClasses: allStyleClasses,
-          comboIdentityByName: allComboIdentityByName,
-          interactiveStylesMap: allInteractiveStylesMap,
-          cmsService,
-          i18nConfig,
-          locale,
-          slugMappings,
-          pagePath: urlPath,
-          themeVars,
-          projectVars,
-          defaultTheme,
-          responsiveScales,
-          promotedComponents,
-          promotedComponentNames,
-          bindCollectionLists,
-        };
-
-        const body = pageData.root || (pageData as any).node;
-        const elements = body ? await nodeToWebflow(body, ctx) : [];
-        normalizeListChildren(elements);
-
-        const pageMeta = extractPageMeta(pageData);
-        allPages.push({
-          title: result.title,
-          slug: slug || 'index',
-          elements,
-          locale,
-          ...buildPageMetaForLocale(pageMeta, locale, i18nConfig),
-        });
-      }
-    } catch (error: any) {
-      console.error(`Error processing ${basePath}:`, error?.message);
-    }
-  }
-
-  // CMS template pages — imported as a single regular Webflow page per locale,
-  // bound to the FIRST CMS item's content. Webflow can't natively bind a page
-  // to a Meno-side collection, and a separate "Sync CMS" flow in the extension
-  // handles collection schema/items, so this code path stays page-only.
-  const templatesDir = projectPaths.templates();
-
-  if (existsSync(templatesDir)) {
-    const templateFiles = readdirSync(templatesDir).filter(f => f.endsWith('.json'));
-
-    for (const file of templateFiles) {
-      const templateContent = await loadJSONFile(join(templatesDir, file));
-      if (!templateContent) continue;
-
-      try {
-        const pageData = parseJSON<JSONPage>(templateContent);
-        if (pageData.meta?.draft === true) continue;
-        if (!isCMSPage(pageData)) continue;
-
-        const cmsSchema = pageData.meta!.cms as CMSSchema;
-        const items = await cmsService.queryItems({ collection: cmsSchema.id });
-        if (items.length === 0) continue;
-
-        const item = items[0];
-        const pageName = file.replace('.json', '');
-
-        for (const localeConfig of localesToBuild) {
-          const locale = localeConfig.code;
-          // Use the first item's resolved URL (from cmsSchema.urlPattern) as
-          // the slug, so a template like `templates/blog.json` lands at
-          // `/blog/<first-slug>` and doesn't collide with a sibling listing
-          // page like `pages/blog.json`.
-          let itemSlug = item[cmsSchema.slugField] ?? item._slug ?? item._filename ?? item._id;
-          if (isI18nValue(itemSlug)) {
-            itemSlug = resolveI18nValue(itemSlug, locale, i18nConfig) as string;
-          }
-          const resolvedItemPath = cmsSchema.urlPattern.replace('{{slug}}', String(itemSlug));
-          const isDefault = locale === i18nConfig.defaultLocale;
-          const localizedItemPath = isDefault
-            ? resolvedItemPath
-            : `/${locale}${resolvedItemPath.startsWith('/') ? '' : '/'}${resolvedItemPath}`;
-          const slug = localizedItemPath.startsWith('/')
-            ? localizedItemPath.substring(1)
-            : localizedItemPath;
-          const urlPath = localizedItemPath;
-          // SSR (`renderPageSSR`) gets the raw item — its `processCMSTemplate`
-          // resolves i18n + richtext at each interpolation. The Webflow path
-          // re-walks the same `pageData.root` with the simpler `resolveTemplate`
-          // (no i18n / richtext awareness), so we hand it a pre-flattened item.
-          const flatItem = flattenCMSItemForLocale(item, locale, i18nConfig);
-          const itemWithUrl: CMSItem = { ...flatItem, _url: urlPath } as CMSItem;
-          const ssrItem: CMSItem = { ...item, _url: urlPath };
-
-          const result = await renderPageSSR(
-            pageData,
-            globalComponents,
-            urlPath,
-            siteUrl,
-            locale,
-            i18nConfig,
-            slugMappings,
-            { cms: ssrItem },
-            cmsService,
-            true
-          );
-
-          const ctx: WebflowEmitContext = {
-            globalComponents,
-            elementPath: [0],
-            fileType: 'page',
-            fileName: pageName,
-            breakpoints,
-            styleClasses: allStyleClasses,
-            comboIdentityByName: allComboIdentityByName,
-            interactiveStylesMap: allInteractiveStylesMap,
-            cmsService,
-            i18nConfig,
-            locale,
-            slugMappings,
-            pagePath: urlPath,
-            cmsContext: { cms: itemWithUrl },
-            // Seed `templateContext` with the bound item so descendants inside
-            // a component slot still see `cms`. `emitInlineComponentBody`
-            // merges `ctx.templateContext` into the body's `instanceProps`
-            // (nodeToWebflow.ts:1140-1143), and `<slot>` rendering forwards
-            // those merged props to slot children — without this, anything
-            // wrapped in (e.g.) Section loses the page-level CMS scope and
-            // `{{cms.title}}` resolves to empty.
-            templateContext: { cms: itemWithUrl } as Record<string, unknown>,
-            themeVars,
-            projectVars,
-            defaultTheme,
-            responsiveScales,
-            promotedComponents,
-            promotedComponentNames,
-            bindCollectionLists,
-          };
-
-          const body = pageData.root || (pageData as any).node;
-          const elements = body ? await nodeToWebflow(body, ctx, { cms: itemWithUrl }) : [];
-          normalizeListChildren(elements);
-
-          const cmsPageMeta = extractPageMeta(pageData);
-          allPages.push({
-            title: result.title,
-            slug,
-            elements,
-            locale,
-            ...buildPageMetaForLocale(cmsPageMeta, locale, i18nConfig),
-          });
-        }
-      } catch (error: any) {
-        console.error(`Error processing template ${file}:`, error?.message);
-      }
-    }
-  }
-
-  // Promoted components (Navigation, Footer) are emitted via the same
-  // `nodeToWebflow` walk as pages, so they share the same `<ul>`-with-
-  // non-`<li>`-children pitfall. Normalize their element trees too before
-  // they leave the build.
-  for (const def of promotedComponents.values()) {
-    normalizeListChildren(def.elements);
-  }
-
-  // 4. Scan assets
-  const styleClasses = Array.from(allStyleClasses.values());
-  const assets = scanAssets(projectPaths.project);
-
-  // 5. Collect component scripts and component-scoped CSS sidecars. Both get
-  //    bundled into the manual-paste UI: scripts as a `<script>` at body end,
-  //    CSS as part of the `<style>` block at head. CSS in particular is
-  //    critical for components that drive visibility through hand-written
-  //    rules (e.g. NavDropdown's `[data-nav-dropdown="container"].open ...`)
-  //    — those don't translate to Webflow's class system at all.
-  const scripts: WebflowScript[] = [];
-  const cssBlocks: string[] = [];
-  for (const [name, def] of Object.entries(globalComponents)) {
-    const code = def.component?.javascript;
-    if (typeof code === 'string' && code.trim().length > 0) {
-      scripts.push({
-        componentName: name,
-        code,
-        defineVars: def.component?.defineVars,
-      });
-    }
-    const css = def.component?.css;
-    if (typeof css === 'string' && css.trim().length > 0) {
-      cssBlocks.push(`/* ${name}.css */\n${css.trim()}`);
-    }
-  }
-  const componentCss = cssBlocks.length > 0 ? cssBlocks.join('\n\n') : undefined;
-
-  // 6. Per-element interactiveStyles → raw CSS for rules Webflow's class
-  //    system can't represent (anything with `prefix`, class-style postfix,
-  //    or breakpoint-divided pseudos). Pseudo-only rules with empty prefix
-  //    have already been written into `primaryClass.pseudoStates` upstream
-  //    via `Style.setProperties({ pseudo })`; we filter those out here so
-  //    the bundle doesn't double-emit them.
-  const interactiveCssBlocks: string[] = [];
-  for (const [elementClass, rules] of allInteractiveStylesMap) {
-    const customRules = rules.filter((r) => !isWebflowHandledRule(r));
-    if (customRules.length === 0) continue;
-    const css = generateInteractiveCSS(elementClass, customRules, breakpoints, undefined, responsiveScales);
-    if (css && css.trim().length > 0) {
-      interactiveCssBlocks.push(css);
-    }
-  }
-  const interactiveCss = interactiveCssBlocks.length > 0
-    ? interactiveCssBlocks.join('\n\n')
-    : undefined;
-
-  return {
-    version: 1,
-    exportedAt: new Date().toISOString(),
-    pages: allPages,
-    styles: styleClasses,
-    cms: [],
-    assets,
-    slugMappings: slugMappings.length > 0 ? slugMappings : undefined,
-    scripts: scripts.length > 0 ? scripts : undefined,
-    components: promotedComponents.size > 0
-      ? Array.from(promotedComponents.values())
-      : undefined,
-    componentCss,
-    interactiveCss,
-    i18n: {
-      defaultLocale: i18nConfig.defaultLocale,
-      locales: i18nConfig.locales.map(l => ({
-        code: l.code,
-        name: l.name,
-        nativeName: l.nativeName,
-      })),
-      selectedLocale,
-    },
-  };
-}
-
-function emptyPayload(): WebflowExportPayload {
-  return {
-    version: 1,
-    exportedAt: new Date().toISOString(),
-    pages: [],
-    styles: [],
-    cms: [],
-    assets: [],
-  };
-}
-

package/lib/server/webflow/index.ts

@@ -1,23 +0,0 @@
-/**
- * Webflow Export Module
- * Re-exports the main build function and types.
- */
-
-export { buildWebflowPayload } from './buildWebflow';
-export { nodeToWebflow } from './nodeToWebflow';
-export { mapStylesToWebflow } from './styleMapper';
-export { wrapInWebflowTemplate } from './templateWrapper';
-export type {
-  WebflowExportPayload,
-  WebflowPage,
-  WebflowElement,
-  WebflowStyleClass,
-  WebflowCMSCollection,
-  WebflowCMSField,
-  WebflowAssetRef,
-  WebflowBreakpoint,
-  WebflowPseudoState,
-  WebflowFieldType,
-  CSSProperties,
-} from './types';
-export { mapCMSFieldType } from './types';