@se-studio/contentful-rest-api 0.1.0

package/dist/index.js

@@ -0,0 +1,1435 @@
+import { createClient } from 'contentful';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/timing.ts
+var timing_exports = {};
+__export(timing_exports, {
+  Timer: () => Timer,
+  createTimer: () => createTimer,
+  logTimingResult: () => logTimingResult
+});
+function formatTimingResult(result, indent = "") {
+  const lines = [];
+  let output = `${result.label}: ${result.duration}ms`;
+  if (result.metadata) {
+    const metadataStr = Object.entries(result.metadata).map(([k, v]) => `${k}: ${v}`).join(", ");
+    output += ` (${metadataStr})`;
+  }
+  if (result.memoryDelta) {
+    const mem = result.memoryDelta;
+    const parts = [];
+    if (Math.abs(mem.heapUsedMB) > 0.01) {
+      parts.push(`heap: ${mem.heapUsedMB >= 0 ? "+" : ""}${mem.heapUsedMB}MB`);
+    }
+    if (Math.abs(mem.rssMB) > 0.01) {
+      parts.push(`rss: ${mem.rssMB >= 0 ? "+" : ""}${mem.rssMB}MB`);
+    }
+    if (Math.abs(mem.externalMB) > 0.01) {
+      parts.push(`ext: ${mem.externalMB >= 0 ? "+" : ""}${mem.externalMB}MB`);
+    }
+    if (parts.length > 0) {
+      output += ` [${parts.join(", ")}]`;
+    }
+  }
+  lines.push(`${indent}${output}`);
+  if (result.children && result.children.length > 0) {
+    for (let i = 0; i < result.children.length; i++) {
+      const child = result.children[i];
+      if (!child) continue;
+      const isLast = i === result.children.length - 1;
+      const childIndent = indent + (isLast ? "  \u2514\u2500 " : "  \u251C\u2500 ");
+      const grandchildIndent = indent + (isLast ? "     " : "  \u2502  ");
+      const childLines = formatTimingResult(child, "").split("\n");
+      lines.push(childIndent + childLines[0]);
+      for (let j = 1; j < childLines.length; j++) {
+        lines.push(grandchildIndent + childLines[j]);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function logTimingResult(result) {
+  if (!shouldLog) return;
+  console.log(`
+[Timing] ${formatTimingResult(result)}`);
+}
+function createTimer(label) {
+  return new Timer(label);
+}
+var isDevelopment, isDebugTimingEnabled, shouldLog, Timer;
+var init_timing = __esm({
+  "src/utils/timing.ts"() {
+    isDevelopment = process.env.NODE_ENV === "development";
+    isDebugTimingEnabled = process.env.DEBUG_TIMING === "true";
+    shouldLog = isDevelopment || isDebugTimingEnabled;
+    Timer = class _Timer {
+      startTime;
+      memoryStart;
+      label;
+      children = [];
+      metadata = {};
+      trackMemory;
+      constructor(label, trackMemory = true) {
+        this.label = label;
+        this.startTime = performance.now();
+        this.trackMemory = trackMemory && shouldLog;
+        if (this.trackMemory && typeof process !== "undefined" && process.memoryUsage) {
+          this.memoryStart = process.memoryUsage();
+        }
+      }
+      /**
+       * Add metadata to the timing result
+       */
+      addMetadata(key, value) {
+        this.metadata[key] = value;
+      }
+      /**
+       * Create and return a child timer
+       */
+      child(label) {
+        return new _Timer(`${this.label} > ${label}`);
+      }
+      /**
+       * End the timer and return the result
+       */
+      end() {
+        const duration = performance.now() - this.startTime;
+        const result = {
+          label: this.label,
+          duration: Math.round(duration * 100) / 100,
+          // Round to 2 decimal places
+          children: this.children.length > 0 ? this.children : void 0,
+          metadata: Object.keys(this.metadata).length > 0 ? this.metadata : void 0
+        };
+        if (this.memoryStart && typeof process !== "undefined" && process.memoryUsage) {
+          const memoryEnd = process.memoryUsage();
+          result.memoryDelta = {
+            heapUsedMB: Number(
+              ((memoryEnd.heapUsed - this.memoryStart.heapUsed) / 1024 / 1024).toFixed(2)
+            ),
+            heapTotalMB: Number(
+              ((memoryEnd.heapTotal - this.memoryStart.heapTotal) / 1024 / 1024).toFixed(2)
+            ),
+            rssMB: Number(((memoryEnd.rss - this.memoryStart.rss) / 1024 / 1024).toFixed(2)),
+            externalMB: Number(
+              ((memoryEnd.external - this.memoryStart.external) / 1024 / 1024).toFixed(2)
+            )
+          };
+        }
+        return result;
+      }
+      /**
+       * End timer and log the result
+       */
+      endAndLog() {
+        const result = this.end();
+        if (shouldLog) {
+          logTimingResult(result);
+        }
+        return result;
+      }
+      /**
+       * Execute a function and time it
+       */
+      static async time(label, fn, metadata) {
+        const timer = new _Timer(label);
+        if (metadata) {
+          for (const [key, value] of Object.entries(metadata)) {
+            timer.addMetadata(key, value);
+          }
+        }
+        const result = await fn();
+        const timing = timer.end();
+        return { result, timing };
+      }
+      /**
+       * Execute a synchronous function and time it
+       */
+      static timeSync(label, fn, metadata) {
+        const timer = new _Timer(label);
+        if (metadata) {
+          for (const [key, value] of Object.entries(metadata)) {
+            timer.addMetadata(key, value);
+          }
+        }
+        const result = fn();
+        const timing = timer.end();
+        return { result, timing };
+      }
+    };
+  }
+});
+function createContentfulClient(config) {
+  return createClient({
+    space: config.spaceId,
+    accessToken: config.accessToken,
+    environment: config.environment || "master",
+    host: config.host,
+    ...config.options
+  });
+}
+function createContentfulPreviewClient(config) {
+  return createClient({
+    space: config.spaceId,
+    accessToken: config.accessToken,
+    environment: config.environment || "master",
+    host: "preview.contentful.com",
+    ...config.options
+  });
+}
+function getContentfulClient(config, preview = false) {
+  return (preview ? createContentfulPreviewClient(config) : createContentfulClient(config)).withoutLinkResolution;
+}
+
+// src/converters/helpers.ts
+function makeContentfulTitle(title, id, prefix = "Title for ") {
+  return title ?? `${prefix}${id}`;
+}
+function makeContentfulDescription(description, id) {
+  return description ?? `Description for ${id}`;
+}
+function lookupAsset(context, asset) {
+  if (!asset) return void 0;
+  return context.assets.get(asset.sys.id);
+}
+var DEFAULT_POSITION_FIELDS = {
+  index: 0,
+  isFirst: false,
+  isLast: false,
+  indexOfType: 0
+};
+function createInternalLink(id, fields, context, href, additionalProps) {
+  const { cmsLabel, title, featuredImage, backgroundColour, textColour, indexed, hidden, slug } = fields;
+  return {
+    type: "Internal link",
+    id,
+    name: cmsLabel,
+    useName: true,
+    text: makeContentfulTitle(title, id),
+    visual: lookupAsset(context, featuredImage),
+    backgroundColour,
+    textColour,
+    indexed,
+    hidden,
+    slug,
+    href,
+    ...additionalProps
+  };
+}
+function addPositionMetadata(items) {
+  if (items.length === 0) return items;
+  const typeCount = /* @__PURE__ */ new Map();
+  return items.map((item, index) => {
+    const currentTypeIndex = typeCount.get(item.type) ?? 0;
+    typeCount.set(item.type, currentTypeIndex + 1);
+    return {
+      ...item,
+      index,
+      isFirst: index === 0,
+      isLast: index === items.length - 1,
+      indexOfType: currentTypeIndex
+    };
+  });
+}
+
+// src/converters/asset.ts
+function convertAssetToVisual(asset, options) {
+  if (!asset) return void 0;
+  const { fields, sys } = asset;
+  if (!fields) return void 0;
+  const { id } = sys;
+  const { file } = fields;
+  if (!file) return void 0;
+  const { contentType } = file;
+  if (contentType?.startsWith("image/")) {
+    const image = convertAssetToImage(file, fields, sys, options);
+    return {
+      id,
+      type: "Visual",
+      image
+    };
+  }
+  if (contentType?.startsWith("video/")) {
+    const video = convertAssetToVideo(file, fields, sys, options);
+    return {
+      id,
+      type: "Visual",
+      video
+    };
+  }
+  return void 0;
+}
+function convertAssetToImage(file, fields, sys, options) {
+  const { id } = sys;
+  const { title, description } = fields;
+  const { contentType, details, url } = file;
+  const { size, image } = details;
+  const { width, height } = image || {};
+  return {
+    ...options,
+    id,
+    type: "Picture",
+    src: `https:${url}`,
+    mimeType: contentType,
+    size,
+    width: width || 0,
+    height: height || 0,
+    name: makeContentfulTitle(title, id),
+    description: makeContentfulDescription(description, id)
+  };
+}
+function convertAssetToVideoDetails(file, sys) {
+  const { id } = sys;
+  const { details, url, contentType, fileName } = file;
+  const { size } = details;
+  return {
+    id,
+    videoUrl: `https:${url}`,
+    size,
+    mimeType: contentType,
+    fileName
+  };
+}
+function convertAssetToVideo(file, fields, sys, options) {
+  const { id } = sys;
+  const { title, description } = fields;
+  const { details } = file;
+  const { image } = details;
+  const { width, height } = image || {};
+  const videoDetails = convertAssetToVideoDetails(file, sys);
+  return {
+    ...options,
+    id,
+    type: "Local video",
+    preview: videoDetails,
+    width: width || 0,
+    height: height || 0,
+    name: makeContentfulTitle(title, id),
+    description: makeContentfulDescription(description, id)
+  };
+}
+function createResponsiveVisual(visual, mobileVisual, customSize) {
+  if (!visual) return void 0;
+  return {
+    visual,
+    mobileVisual,
+    visualCustomSize: customSize
+  };
+}
+function convertMediaEntryToVisual(context, entry) {
+  const { fields, sys } = entry;
+  if (!fields) return void 0;
+  const baseVisual = lookupAsset(context, fields.asset);
+  if (!baseVisual) return void 0;
+  const metadata = {
+    name: makeContentfulTitle(fields.name, sys.id),
+    nameAsCaption: fields.nameAsCaption ?? null,
+    dontCrop: fields.dontCrop ?? null,
+    verticalCropPosition: fields.verticalCropPosition ?? null,
+    horizontalCropPosition: fields.horizontalCropPosition ?? null,
+    horizontalPosition: fields.horizontalPosition ?? null,
+    widthPercent: fields.width ?? null
+  };
+  const visual = {
+    ...baseVisual,
+    id: sys.id
+  };
+  if (baseVisual.image) {
+    visual.image = {
+      ...baseVisual.image,
+      ...metadata
+    };
+  } else if (baseVisual.video) {
+    visual.video = {
+      ...baseVisual.video,
+      ...metadata,
+      autoPlay: fields.autoplay ?? null,
+      loop: fields.loop ?? null,
+      hideControls: fields.hideControls ?? null
+    };
+  }
+  return visual;
+}
+function convertExternalVideoEntryToVisual(context, entry) {
+  const { fields, sys } = entry;
+  if (!fields || !fields.url) return void 0;
+  const previewVisual = lookupAsset(context, fields.preview);
+  const posterVisual = lookupAsset(context, fields.posterImage);
+  const preview = previewVisual?.video?.type === "Local video" ? previewVisual.video.preview : void 0;
+  const poster = posterVisual?.image?.type === "Picture" ? posterVisual.image.src : void 0;
+  const mapHorizontal = (value) => {
+    if (!value) return null;
+    return value === "Center" ? "Middle" : value;
+  };
+  const video = {
+    id: sys.id,
+    type: "External video",
+    name: makeContentfulTitle(fields.name, sys.id),
+    nameAsCaption: fields.nameAsCaption ?? null,
+    external: fields.url,
+    preview,
+    poster,
+    autoPlay: fields.autoPlay ?? null,
+    loop: fields.loop ?? null,
+    hideControls: fields.hideControls ?? null,
+    dontCrop: fields.dontCrop ?? null,
+    verticalCropPosition: fields.verticalCropPosition ?? null,
+    horizontalCropPosition: mapHorizontal(fields.horizontalCropPosition),
+    horizontalPosition: fields.horizontalPosition ?? null,
+    widthPercent: fields.width ?? null
+  };
+  return {
+    id: sys.id,
+    type: "Visual",
+    video
+  };
+}
+function lookupMediaEntry(context, link) {
+  if (!link) return void 0;
+  const id = link.sys.id;
+  const possibleEntry = context.includes.get(id);
+  if (!possibleEntry) {
+    return void 0;
+  }
+  const { type, entry } = possibleEntry;
+  if (type === "media") {
+    return convertMediaEntryToVisual(
+      context,
+      entry
+    );
+  }
+  if (type === "externalVideo") {
+    return convertExternalVideoEntryToVisual(
+      context,
+      entry
+    );
+  }
+  return void 0;
+}
+
+// src/converters/externalComponent.ts
+function baseExternalComponentConverter(_context, entry) {
+  const { sys, fields } = entry;
+  const {
+    externalComponentType,
+    cmsLabel,
+    data,
+    heading: _heading,
+    // Exclude: not in target interface
+    ...simpleFields
+    // backgroundColour, textColour
+  } = fields;
+  return {
+    type: "External component",
+    id: sys.id,
+    name: cmsLabel ?? `External component ${sys.id}`,
+    cmsLabel: cmsLabel ?? null,
+    externalType: externalComponentType,
+    data: data ?? null,
+    ...DEFAULT_POSITION_FIELDS,
+    ...simpleFields,
+    backgroundOverlayOpacity: null,
+    backgroundVisual: void 0
+  };
+}
+
+// src/converters/resolver.ts
+function resolveHelper(context, entry, getResolver) {
+  const id = entry.sys.id;
+  const possibleEntry = context.includes.get(id);
+  if (!possibleEntry) {
+    throw new Error(`Cannot find included entry for link with id ${id}`);
+  }
+  if (!possibleEntry.resolved) {
+    const resolver = getResolver(possibleEntry.type);
+    if (!resolver) {
+      throw new Error(
+        `No resolver found for link type ${possibleEntry.type} (${JSON.stringify(possibleEntry)}) [${JSON.stringify(entry)}]`
+      );
+    }
+    const resolved = resolver(
+      context,
+      possibleEntry.entry
+    );
+    possibleEntry.resolved = resolved;
+    return resolved;
+  }
+  return possibleEntry.resolved;
+}
+function resolveLink(context, entry) {
+  return resolveHelper(
+    context,
+    entry,
+    (type) => context.linkResolver.get(type)
+  );
+}
+function resolveNavigationItem(context, entry) {
+  return resolveHelper(
+    context,
+    entry,
+    () => context.navigationItemResolver
+  );
+}
+function resolveCollectionContent(context, entry) {
+  return resolveHelper(context, entry, (type) => {
+    if (type === "component") {
+      return context.componentResolver;
+    }
+    if (type === "collection") {
+      return context.collectionResolver;
+    }
+    return void 0;
+  });
+}
+function resolvePageContent(context, entry) {
+  const id = entry.sys.id;
+  const possibleEntry = context.includes.get(id);
+  if (!possibleEntry) {
+    throw new Error(`Cannot find included entry for content with id ${id}`);
+  }
+  const { type } = possibleEntry;
+  if (type === "component" || type === "collection") {
+    return resolveCollectionContent(context, entry);
+  }
+  if (type === "media") {
+    const visual = convertMediaEntryToVisual(
+      context,
+      possibleEntry.entry
+    );
+    if (!visual) {
+      throw new Error(`Failed to convert media entry with id ${id}`);
+    }
+    return visual;
+  }
+  if (type === "externalVideo") {
+    const visual = convertExternalVideoEntryToVisual(
+      context,
+      possibleEntry.entry
+    );
+    if (!visual) {
+      throw new Error(`Failed to convert externalVideo entry with id ${id}`);
+    }
+    return visual;
+  }
+  if (type === "externalComponent") {
+    return resolveHelper(context, entry, () => baseExternalComponentConverter);
+  }
+  if (context.linkResolver.has(type)) {
+    return resolveLink(context, entry);
+  }
+  throw new Error(`Unknown content type "${type}" for entry with id ${id}`);
+}
+function resolveRichTextDocument(context, richText) {
+  if (!richText) {
+    return void 0;
+  }
+  const resolvingEntries = /* @__PURE__ */ new Set();
+  const resolvedEntries = /* @__PURE__ */ new Set();
+  const resolveNode = (node) => {
+    if (!("content" in node)) {
+      return node;
+    }
+    const block = node;
+    if (block.data.target && "sys" in block.data.target && block.data.target.sys.linkType === "Entry") {
+      const entryId = block.data.target.sys.id;
+      if (resolvingEntries.has(entryId)) {
+        console.warn(
+          `Circular reference detected in rich text resolution for entry ${entryId}. Skipping to prevent infinite recursion.`
+        );
+        return {
+          ...block,
+          content: block.content?.map(resolveNode)
+        };
+      }
+      if (resolvedEntries.has(entryId)) {
+        return {
+          ...block,
+          content: block.content?.map(resolveNode)
+        };
+      }
+      try {
+        resolvingEntries.add(entryId);
+        const resolvedEntry = resolvePageContent(
+          context,
+          block.data.target
+        );
+        resolvingEntries.delete(entryId);
+        resolvedEntries.add(entryId);
+        return {
+          ...block,
+          data: {
+            ...block.data,
+            target: resolvedEntry
+          },
+          content: block.content?.map(resolveNode)
+        };
+      } catch (error) {
+        resolvingEntries.delete(entryId);
+        console.error(`Failed to resolve entry with id ${entryId}:`, error);
+        return {
+          ...block,
+          content: block.content?.map(resolveNode)
+        };
+      }
+    }
+    if (block.data.target && "sys" in block.data.target && block.data.target.sys.linkType === "Asset") {
+      try {
+        const resolvedAsset = lookupAsset(context, block.data.target);
+        if (resolvedAsset) {
+          return {
+            ...block,
+            data: {
+              ...block.data,
+              target: resolvedAsset
+            },
+            content: block.content?.map(resolveNode)
+          };
+        }
+      } catch (error) {
+        console.error(
+          `Failed to resolve embedded-asset-block with id ${block.data.target.sys.id}:`,
+          error
+        );
+        return {
+          ...block,
+          content: block.content?.map(resolveNode)
+        };
+      }
+    }
+    return {
+      ...block,
+      content: block.content?.map(resolveNode)
+    };
+  };
+  const resolved = resolveNode(richText);
+  return { json: resolved };
+}
+
+// src/converters/collection.ts
+function baseCollectionConverter(context, entry) {
+  const { sys, fields } = entry;
+  const {
+    // Fields requiring transformation
+    backgroundVisual: bgVisual,
+    mobileBackgroundVisual: mobileBgVisual,
+    visual: visualField,
+    mobileVisual: mobileVisualField,
+    visualCustomSize,
+    icon: iconField,
+    links: linksField,
+    contents: contentsField,
+    body: bodyField,
+    additionalCopy: additionalCopyField,
+    // Field name change
+    collectionType,
+    // CMS-only fields (must exclude)
+    textSize: _textSize,
+    showHeading: _showHeading,
+    // Already handled elsewhere
+    cmsLabel,
+    ...simpleFields
+    // anchor, backgroundColour, textColour, preHeading, heading, postHeading, backgroundOverlayOpacity
+  } = fields;
+  const backgroundVisual = createResponsiveVisual(
+    lookupAsset(context, bgVisual),
+    lookupAsset(context, mobileBgVisual)
+  );
+  const visual = createResponsiveVisual(
+    lookupMediaEntry(context, visualField),
+    lookupMediaEntry(context, mobileVisualField),
+    visualCustomSize
+  );
+  return {
+    type: "Collection",
+    id: sys.id,
+    name: cmsLabel,
+    cmsLabel,
+    collectionType,
+    ...DEFAULT_POSITION_FIELDS,
+    ...simpleFields,
+    body: resolveRichTextDocument(context, bodyField),
+    additionalCopy: resolveRichTextDocument(context, additionalCopyField),
+    icon: lookupAsset(context, iconField),
+    backgroundVisual,
+    visual,
+    links: linksField?.map((link) => resolveLink(context, link)),
+    contents: contentsField?.map((content) => resolveCollectionContent(context, content))
+  };
+}
+
+// src/converters/component.ts
+function baseComponentConverter(context, entry) {
+  const { sys, fields } = entry;
+  const {
+    // Fields requiring transformation
+    backgroundVisual: bgVisual,
+    mobileBackgroundVisual: mobileBgVisual,
+    visual: visualField,
+    mobileVisual: mobileVisualField,
+    visualCustomSize,
+    icon: iconField,
+    links: linksField,
+    body: bodyField,
+    additionalCopy: additionalCopyField,
+    // Field name change
+    componentType,
+    // CMS-only fields (must exclude)
+    textSize: _textSize,
+    showHeading: _showHeading,
+    otherMedia: _otherMedia,
+    otherVisuals: _otherVisuals,
+    // Already handled elsewhere
+    cmsLabel,
+    ...simpleFields
+    // anchor, backgroundColour, textColour, preHeading, heading, postHeading, backgroundOverlayOpacity
+  } = fields;
+  const backgroundVisual = createResponsiveVisual(
+    lookupAsset(context, bgVisual),
+    lookupAsset(context, mobileBgVisual)
+  );
+  const visual = createResponsiveVisual(
+    lookupMediaEntry(context, visualField),
+    lookupMediaEntry(context, mobileVisualField),
+    visualCustomSize
+  );
+  return {
+    type: "Component",
+    id: sys.id,
+    name: cmsLabel,
+    cmsLabel,
+    componentType,
+    ...DEFAULT_POSITION_FIELDS,
+    ...simpleFields,
+    body: resolveRichTextDocument(context, bodyField),
+    additionalCopy: resolveRichTextDocument(context, additionalCopyField),
+    icon: lookupAsset(context, iconField),
+    backgroundVisual,
+    visual,
+    links: linksField?.map((link) => resolveLink(context, link))
+  };
+}
+
+// src/converters/link.ts
+function baseLinkConverter(context, entry) {
+  const { sys, fields } = entry;
+  if (sys.contentType.sys.id !== "link") {
+    throw new Error(`Invalid content type: expected "link", got "${sys.contentType.sys.id}"`);
+  }
+  const id = sys.id;
+  const name = fields.name;
+  const useName = fields.useName;
+  const text = useName ? name : fields.linkText ?? makeContentfulTitle(fields.linkText, id, "Link text for ");
+  const icon = lookupAsset(context, fields.icon);
+  const backgroundColour = fields.backgroundColour ?? null;
+  const textColour = fields.textColour ?? null;
+  const variant = fields.variant;
+  const size = fields.size;
+  const baseProps = {
+    id,
+    useName,
+    name,
+    text,
+    icon,
+    backgroundColour,
+    textColour,
+    variant,
+    size
+  };
+  if (fields.internal) {
+    const internalTarget = resolveLink(context, fields.internal);
+    return {
+      ...baseProps,
+      type: "Internal link",
+      href: internalTarget.href,
+      slug: internalTarget.slug,
+      indexed: internalTarget.indexed,
+      hidden: internalTarget.hidden,
+      tags: internalTarget.tags
+    };
+  }
+  if (fields.external) {
+    return {
+      ...baseProps,
+      type: "External link",
+      href: fields.external
+    };
+  }
+  if (fields.downloadAsset) {
+    const asset = lookupAsset(context, fields.downloadAsset);
+    let href = null;
+    if (asset?.image?.type === "Picture") {
+      href = asset.image.src;
+    } else if (asset?.image?.type === "Svg image") {
+      href = asset.image.svgSrc;
+    } else if (asset?.video) {
+      if (asset.video.type === "Local video") {
+        href = asset.video.preview.videoUrl;
+      } else if (asset.video.type === "Full video") {
+        href = asset.video.full.videoUrl;
+      } else if (asset.video.type === "External video") {
+        href = asset.video.external;
+      }
+    }
+    return {
+      ...baseProps,
+      type: "Download link",
+      href,
+      visual: asset
+    };
+  }
+  return {
+    ...baseProps,
+    type: "Blank link",
+    href: null
+  };
+}
+
+// src/converters/template.ts
+function resolveTemplate(context, link) {
+  const id = link.sys.id;
+  const possibleEntry = context.includes.get(id);
+  if (!possibleEntry || possibleEntry.type !== "template") {
+    return null;
+  }
+  const entry = possibleEntry.entry;
+  const { fields } = entry;
+  if (!fields) {
+    return null;
+  }
+  const preContent = fields.preContent?.map((content) => resolvePageContent(context, content)) ?? [];
+  const postContent = fields.postContent?.map((content) => resolvePageContent(context, content)) ?? [];
+  const menu = fields.menu ? resolveNavigation(context, fields.menu) : void 0;
+  const footer = fields.footer ? resolveNavigation(context, fields.footer) : void 0;
+  const stickyNav = fields.flags?.includes("Sticky nav") ?? false;
+  const { backgroundColour, textColour } = fields;
+  return {
+    preContent,
+    postContent,
+    menu,
+    footer,
+    backgroundColour,
+    textColour,
+    stickyNav
+  };
+}
+function resolveNavigation(context, link) {
+  const id = link.sys.id;
+  const possibleEntry = context.includes.get(id);
+  if (!possibleEntry || possibleEntry.type !== "navigation") {
+    return void 0;
+  }
+  const entry = possibleEntry.entry;
+  const { sys, fields } = entry;
+  if (!fields) {
+    return void 0;
+  }
+  const entries = fields.entries?.map((item) => resolveNavigationItem(context, item)) ?? [];
+  const { name, textColour, backgroundColour } = fields;
+  return {
+    id: sys.id,
+    name,
+    entries,
+    textColour,
+    backgroundColour
+  };
+}
+
+// src/converters/page.ts
+function basePageConverter(context, entry) {
+  const { sys, fields } = entry;
+  const {
+    slug,
+    title,
+    description,
+    featuredImage,
+    tags,
+    content,
+    template: templateLink,
+    topContent: topContentLinks,
+    bottomContent: bottomContentLinks,
+    ...simpleFields
+  } = fields;
+  const template = templateLink ? resolveTemplate(context, templateLink) : null;
+  const topContent = topContentLinks?.map((c) => resolvePageContent(context, c)) ?? [];
+  const pageContent = content?.map((c) => resolvePageContent(context, c)) ?? [];
+  const bottomContent = bottomContentLinks?.map((c) => resolvePageContent(context, c)) ?? [];
+  const preContent = template?.preContent ?? [];
+  const postContent = template?.postContent ?? [];
+  const contents = addPositionMetadata([
+    ...topContent,
+    ...preContent,
+    ...pageContent,
+    ...postContent,
+    ...bottomContent
+  ]);
+  return {
+    type: "Page",
+    id: sys.id,
+    isHomePage: slug === "index",
+    slug,
+    title: makeContentfulTitle(title, sys.id),
+    description: makeContentfulDescription(description, sys.id),
+    featuredImage: lookupAsset(context, featuredImage),
+    tags: tags?.map((tag) => resolveLink(context, tag)),
+    contents,
+    ...simpleFields,
+    menu: template?.menu,
+    footer: template?.footer
+  };
+}
+function calculatePageHref(slug) {
+  if (slug === "index") {
+    return "/";
+  }
+  return `/${slug}/`;
+}
+function basePageLinkConverter(context, entry) {
+  const { sys, fields } = entry;
+  if (sys.contentType.sys.id !== "page") {
+    throw new Error(`Invalid content type: expected "page", got "${sys.contentType.sys.id}"`);
+  }
+  return createInternalLink(
+    sys.id,
+    {
+      cmsLabel: fields.cmsLabel,
+      title: fields.title,
+      featuredImage: fields.featuredImage,
+      backgroundColour: fields.backgroundColour,
+      textColour: fields.textColour,
+      indexed: fields.indexed,
+      hidden: fields.hidden,
+      slug: fields.slug
+    },
+    context,
+    calculatePageHref(fields.slug),
+    { tags: fields.tags?.map((tag) => resolveLink(context, tag)) }
+  );
+}
+function calculatePageVariantHref(slug) {
+  return `/${slug}/`;
+}
+function basePageVariantLinkConverter(context, entry) {
+  const { sys, fields } = entry;
+  if (sys.contentType.sys.id !== "pageVariant") {
+    throw new Error(
+      `Invalid content type: expected "pageVariant", got "${sys.contentType.sys.id}"`
+    );
+  }
+  return createInternalLink(
+    sys.id,
+    {
+      cmsLabel: fields.cmsLabel,
+      title: fields.title,
+      featuredImage: fields.featuredImage,
+      backgroundColour: fields.backgroundColour,
+      textColour: fields.textColour,
+      indexed: fields.indexed,
+      hidden: fields.hidden,
+      slug: fields.slug
+    },
+    context,
+    calculatePageVariantHref(fields.slug),
+    { tags: fields.tags?.map((tag) => resolveLink(context, tag)) }
+  );
+}
+
+// src/converters/person.ts
+function calculatePersonHref(slug) {
+  return `/people/${slug}/`;
+}
+function basePersonLinkConverter(context, entry) {
+  const { sys, fields } = entry;
+  if (sys.contentType.sys.id !== "person") {
+    throw new Error(`Invalid content type: expected "person", got "${sys.contentType.sys.id}"`);
+  }
+  return createInternalLink(
+    sys.id,
+    {
+      cmsLabel: fields.name,
+      // Person has no cmsLabel, use name field
+      title: fields.name,
+      featuredImage: fields.media,
+      // Person uses 'media' not 'featuredImage'
+      backgroundColour: fields.backgroundColour,
+      textColour: fields.textColour,
+      indexed: fields.indexed,
+      hidden: fields.hidden,
+      slug: fields.slug
+    },
+    context,
+    calculatePersonHref(fields.slug)
+  );
+}
+
+// src/converters/article.ts
+function baseArticleConverter(context, entry) {
+  const { sys, fields } = entry;
+  const {
+    slug,
+    title,
+    description,
+    featuredImage,
+    tags,
+    content,
+    template: templateLink,
+    topContent: topContentLinks,
+    bottomContent: bottomContentLinks,
+    articleType,
+    ...simpleFields
+  } = fields;
+  const articleTypeLink = resolveLink(context, articleType);
+  const template = templateLink ? resolveTemplate(context, templateLink) : null;
+  const topContent = topContentLinks?.map((c) => resolvePageContent(context, c)) ?? [];
+  const articleContent = content?.map((c) => resolvePageContent(context, c)) ?? [];
+  const bottomContent = bottomContentLinks?.map((c) => resolvePageContent(context, c)) ?? [];
+  const preContent = template?.preContent ?? [];
+  const postContent = template?.postContent ?? [];
+  const contents = addPositionMetadata([
+    ...topContent,
+    ...preContent,
+    ...articleContent,
+    ...postContent,
+    ...bottomContent
+  ]);
+  return {
+    type: "Article",
+    id: sys.id,
+    slug,
+    title: makeContentfulTitle(title, sys.id),
+    description: makeContentfulDescription(description, sys.id),
+    featuredImage: lookupAsset(context, featuredImage),
+    articleType: articleTypeLink,
+    tags: tags?.map((tag) => resolveLink(context, tag)),
+    contents,
+    ...simpleFields,
+    // Note: summary field exists in Contentful but is not part of IArticle interface
+    // Keeping it in simpleFields for potential future use
+    menu: template?.menu,
+    footer: template?.footer
+  };
+}
+function calculateArticleTypeHref(slug) {
+  return `/${slug}/`;
+}
+function calculateArticleHref(articleTypeSlug, slug) {
+  return `${calculateArticleTypeHref(articleTypeSlug)}${slug}/`;
+}
+function baseArticleLinkConverter(context, entry) {
+  const { sys, fields } = entry;
+  if (sys.contentType.sys.id !== "article") {
+    throw new Error(`Invalid content type: expected "article", got "${sys.contentType.sys.id}"`);
+  }
+  const articleTypeLink = resolveLink(context, fields.articleType);
+  return createInternalLink(
+    sys.id,
+    {
+      cmsLabel: fields.cmsLabel,
+      title: fields.title,
+      featuredImage: fields.featuredImage,
+      backgroundColour: fields.backgroundColour,
+      textColour: fields.textColour,
+      indexed: fields.indexed,
+      hidden: fields.hidden,
+      slug: fields.slug
+    },
+    context,
+    calculateArticleHref(articleTypeLink.slug, fields.slug),
+    { tags: fields.tags?.map((tag) => resolveLink(context, tag)) }
+  );
+}
+function baseArticleTypeLinkConverter(context, entry) {
+  const { sys, fields } = entry;
+  if (sys.contentType.sys.id !== "articleType") {
+    throw new Error(
+      `Invalid content type: expected "articleType", got "${sys.contentType.sys.id}"`
+    );
+  }
+  return createInternalLink(
+    sys.id,
+    {
+      cmsLabel: fields.name,
+      title: fields.name,
+      featuredImage: fields.featuredImage,
+      backgroundColour: fields.backgroundColour,
+      textColour: fields.textColour,
+      indexed: fields.indexed,
+      hidden: fields.hidden,
+      slug: fields.slug
+    },
+    context,
+    calculateArticleTypeHref(fields.slug)
+  );
+}
+
+// src/converters/navigationItem.ts
+function createLink(context, entry) {
+  const {
+    sys: { id },
+    fields
+  } = entry;
+  const { title, link, internal, icon, useTitle, ...otherFields } = fields;
+  if (link) {
+    return {
+      type: "External link",
+      id,
+      href: link,
+      icon: lookupAsset(context, icon),
+      name: makeContentfulTitle(title, id),
+      ...useTitle && { text: title },
+      ...otherFields
+    };
+  }
+  if (internal) {
+    const resolved = resolveLink(context, internal);
+    return resolved;
+  }
+  return void 0;
+}
+function baseNavigationItemConverter(context, entry) {
+  const { sys, fields } = entry;
+  const { longText, navigationItems } = fields;
+  const link = createLink(context, entry);
+  const resolvedNavigationItems = navigationItems?.map((item) => resolveNavigationItem(context, item)).filter((item) => item !== void 0);
+  return {
+    id: sys.id,
+    longText,
+    link,
+    entries: resolvedNavigationItems
+  };
+}
+
+// src/converters/tag.ts
+function calculateTagHref(slug) {
+  return `/tag/${slug}/`;
+}
+function baseTagLinkConverter(context, entry) {
+  const { sys, fields } = entry;
+  if (sys.contentType.sys.id !== "tag") {
+    throw new Error(`Invalid content type: expected "tag", got "${sys.contentType.sys.id}"`);
+  }
+  return createInternalLink(
+    sys.id,
+    {
+      cmsLabel: fields.cmsLabel,
+      title: fields.name,
+      featuredImage: fields.featuredImage,
+      backgroundColour: fields.backgroundColour,
+      textColour: fields.textColour,
+      indexed: fields.indexed,
+      hidden: fields.hidden,
+      slug: fields.slug
+    },
+    context,
+    calculateTagHref(fields.slug)
+  );
+}
+
+// src/utils/errors.ts
+var ContentfulError = class _ContentfulError extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "ContentfulError";
+    Object.setPrototypeOf(this, _ContentfulError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends ContentfulError {
+  constructor(message, retryAfter, details) {
+    super(message, 429, details);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var EntryNotFoundError = class _EntryNotFoundError extends ContentfulError {
+  constructor(entryId, contentType) {
+    super(`Entry not found: ${entryId}${contentType ? ` (${contentType})` : ""}`, 404);
+    this.entryId = entryId;
+    this.contentType = contentType;
+    this.name = "EntryNotFoundError";
+    Object.setPrototypeOf(this, _EntryNotFoundError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends ContentfulError {
+  constructor(message = "Authentication failed") {
+    super(message, 401);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends ContentfulError {
+  constructor(message, validationErrors) {
+    super(message, 400, validationErrors);
+    this.validationErrors = validationErrors;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+function isContentfulError(error) {
+  return error instanceof ContentfulError;
+}
+function isRateLimitError(error) {
+  return error instanceof RateLimitError;
+}
+function isRetryableError(error) {
+  if (isRateLimitError(error)) {
+    return true;
+  }
+  if (isContentfulError(error)) {
+    return error.statusCode !== void 0 && (error.statusCode >= 500 || error.statusCode === 429);
+  }
+  return false;
+}
+function getRetryAfter(error) {
+  if (isRateLimitError(error)) {
+    return error.retryAfter;
+  }
+  return void 0;
+}
+
+// src/utils/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  // 1 second
+  maxDelay: 3e4,
+  // 30 seconds
+  backoffMultiplier: 2
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateBackoffDelay(attempt, config, retryAfter) {
+  if (retryAfter !== void 0) {
+    return Math.min(retryAfter * 1e3, config.maxDelay);
+  }
+  const exponentialDelay = config.initialDelay * config.backoffMultiplier ** attempt;
+  const jitter = Math.random() * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, config.maxDelay);
+}
+async function withRetry(fn, config) {
+  const retryConfig = {
+    ...DEFAULT_RETRY_CONFIG,
+    ...config
+  };
+  let lastError;
+  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === retryConfig.maxRetries) {
+        break;
+      }
+      if (!isRetryableError(error)) {
+        throw error;
+      }
+      const retryAfter = getRetryAfter(error);
+      const delay = calculateBackoffDelay(attempt, retryConfig, retryAfter);
+      if (typeof process !== "undefined" && process.env?.NODE_ENV !== "production") {
+        console.warn(
+          `Retry attempt ${attempt + 1}/${retryConfig.maxRetries} after ${delay}ms`,
+          error
+        );
+      }
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+var RateLimiter = class {
+  constructor(maxTokens, refillRate) {
+    this.maxTokens = maxTokens;
+    this.refillRate = refillRate;
+    this.tokens = maxTokens;
+    this.lastRefill = Date.now();
+  }
+  tokens;
+  lastRefill;
+  /**
+   * Refills tokens based on time elapsed
+   */
+  refill() {
+    const now = Date.now();
+    const timePassed = (now - this.lastRefill) / 1e3;
+    const tokensToAdd = timePassed * this.refillRate;
+    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+    this.lastRefill = now;
+  }
+  /**
+   * Attempts to consume a token
+   * @returns true if token was consumed, false if rate limited
+   */
+  tryConsume() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Waits until a token is available and consumes it
+   */
+  async consume() {
+    while (!this.tryConsume()) {
+      const waitTime = 1 / this.refillRate * 1e3;
+      await sleep(waitTime);
+    }
+  }
+  /**
+   * Gets current number of available tokens
+   */
+  getAvailableTokens() {
+    this.refill();
+    return Math.floor(this.tokens);
+  }
+};
+
+// src/utils/index.ts
+init_timing();
+
+// src/api.ts
+function convertAllAssets(response) {
+  const visuals = /* @__PURE__ */ new Map();
+  const assets = response.includes?.Asset;
+  if (assets && assets.length > 0) {
+    for (const asset of assets) {
+      const visual = convertAssetToVisual(asset);
+      if (visual) {
+        visuals.set(visual.id, visual);
+      }
+    }
+  }
+  return visuals;
+}
+function convertAllIncludes(response) {
+  const includes = /* @__PURE__ */ new Map();
+  const entries = [...response.items, ...response.includes?.Entry || []];
+  if (entries && entries.length > 0) {
+    for (const entry of entries) {
+      if (entry?.sys && entry.fields) {
+        includes.set(entry.sys.id, {
+          id: entry.sys.id,
+          type: entry.sys.contentType.sys.id,
+          entry
+        });
+      }
+    }
+  }
+  return includes;
+}
+async function contentfulPageRest(context, config, slug, options) {
+  const totalTimer = new Timer(`contentfulPageRest(${slug})`);
+  const client = getContentfulClient(config, options?.preview);
+  const fetchFn = async () => {
+    const apiFetchTimer = new Timer("API fetch");
+    const response = await client.getEntries({
+      content_type: "page",
+      "fields.slug": slug,
+      include: 10,
+      locale: options?.locale,
+      limit: 1
+    });
+    const apiFetchTiming = apiFetchTimer.end();
+    const pageEntry = response.items[0];
+    if (!pageEntry || !pageEntry.fields) {
+      totalTimer.endAndLog();
+      return null;
+    }
+    const assetTimer = new Timer("Asset conversion");
+    const assets = convertAllAssets(response);
+    const assetTiming = assetTimer.end();
+    assetTiming.metadata = { count: assets.size };
+    const includesTimer = new Timer("Includes indexing");
+    const includes = convertAllIncludes(response);
+    const includesTiming = includesTimer.end();
+    includesTiming.metadata = { count: includes.size };
+    const fullContext = {
+      ...context,
+      includes,
+      assets
+    };
+    const conversionTimer = new Timer("Page conversion");
+    const converted = fullContext.pageResolver(fullContext, pageEntry);
+    const conversionTiming = conversionTimer.end();
+    const totalTiming = totalTimer.end();
+    totalTiming.children = [apiFetchTiming, assetTiming, includesTiming, conversionTiming];
+    const { logTimingResult: logTimingResult2 } = await Promise.resolve().then(() => (init_timing(), timing_exports));
+    logTimingResult2(totalTiming);
+    return converted;
+  };
+  if (options?.retry) {
+    return await withRetry(fetchFn, options.retry);
+  }
+  return await fetchFn();
+}
+function createBaseConverterContext() {
+  const linkResolver = /* @__PURE__ */ new Map();
+  linkResolver.set("page", basePageLinkConverter);
+  linkResolver.set("article", baseArticleLinkConverter);
+  linkResolver.set(
+    "articleType",
+    baseArticleTypeLinkConverter
+  );
+  linkResolver.set("tag", baseTagLinkConverter);
+  linkResolver.set("person", basePersonLinkConverter);
+  linkResolver.set(
+    "pageVariant",
+    basePageVariantLinkConverter
+  );
+  linkResolver.set("link", baseLinkConverter);
+  return {
+    pageResolver: basePageConverter,
+    navigationItemResolver: baseNavigationItemConverter,
+    articleResolver: baseArticleConverter,
+    componentResolver: baseComponentConverter,
+    collectionResolver: baseCollectionConverter,
+    linkResolver
+  };
+}
+async function contentfulArticleRest(context, config, slug, articleTypeSlug, options) {
+  const client = getContentfulClient(config, options?.preview);
+  const fetchFn = async () => {
+    const response = await client.getEntries({
+      content_type: "article",
+      "fields.slug": slug,
+      "fields.articleType.sys.contentType.sys.id": "articleType",
+      "fields.articleType.fields.slug": articleTypeSlug,
+      include: 10,
+      locale: options?.locale,
+      limit: 1
+    });
+    const articleEntry = response.items[0];
+    if (!articleEntry || !articleEntry.fields) {
+      return null;
+    }
+    const assets = convertAllAssets(response);
+    const includes = convertAllIncludes(response);
+    const fullContext = {
+      ...context,
+      includes,
+      assets
+    };
+    const converted = fullContext.articleResolver(fullContext, articleEntry);
+    return converted;
+  };
+  if (options?.retry) {
+    return await withRetry(fetchFn, options.retry);
+  }
+  return await fetchFn();
+}
+
+export { AuthenticationError, ContentfulError, EntryNotFoundError, RateLimitError, RateLimiter, Timer, ValidationError, basePageConverter, calculateBackoffDelay, contentfulArticleRest, contentfulPageRest, createBaseConverterContext, createContentfulClient, createContentfulPreviewClient, createTimer, getContentfulClient, getRetryAfter, isContentfulError, isRateLimitError, isRetryableError, logTimingResult, withRetry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map