mitway-tagger 1.3.0

package/dist/index.js

@@ -0,0 +1,865 @@
+// src/features/jsxSource.ts
+var VIRTUAL_JSX_RUNTIME = "virtual:mitway-jsx-runtime";
+var RESOLVED_VIRTUAL_JSX_RUNTIME = "\0" + VIRTUAL_JSX_RUNTIME;
+var ORIGINAL_JSX_RUNTIME = "\0__original_react_jsx_dev_runtime";
+var JSX_RUNTIME_CODE = `
+import * as OriginalRuntime from '\\0__original_react_jsx_dev_runtime';
+
+// Symbol for storing source info on DOM nodes
+const SOURCE_SYMBOL = Symbol.for('__mitwaySource__');
+
+// Global map of source locations to DOM elements (using WeakRef)
+if (typeof window !== 'undefined' && !window.mitwaySourceMap) {
+  window.mitwaySourceMap = new Map();
+}
+
+/**
+ * Creates a ref callback that attaches source info to the DOM node
+ */
+function createSourceRef(source, existingRef) {
+  return (node) => {
+    if (node && source) {
+      // Attach source info directly to the DOM node
+      node[SOURCE_SYMBOL] = {
+        fileName: source.fileName,
+        lineNumber: source.lineNumber,
+        columnNumber: source.columnNumber,
+      };
+      
+      // Add to global source map for lookup
+      if (typeof window !== 'undefined' && window.mitwaySourceMap) {
+        const key = source.fileName + ':' + source.lineNumber + ':' + source.columnNumber;
+        
+        if (!window.mitwaySourceMap.has(key)) {
+          window.mitwaySourceMap.set(key, new Set());
+        }
+        
+        // Use WeakRef to avoid memory leaks
+        const weakRef = new WeakRef(node);
+        window.mitwaySourceMap.get(key).add(weakRef);
+        
+        // Cleanup dead refs periodically
+        const refs = window.mitwaySourceMap.get(key);
+        if (refs.size > 100) {
+          for (const ref of refs) {
+            if (!ref.deref()) {
+              refs.delete(ref);
+            }
+          }
+        }
+      }
+    }
+    
+    // Call existing ref if present
+    if (existingRef) {
+      if (typeof existingRef === 'function') {
+        existingRef(node);
+      } else if (typeof existingRef === 'object') {
+        existingRef.current = node;
+      }
+    }
+  };
+}
+
+/**
+ * Custom jsxDEV that wraps the original with source tracking
+ */
+export function jsxDEV(type, props, key, isStaticChildren, source, self) {
+  // Only track HTML elements and custom components, not fragments
+  if (source && type && typeof type !== 'symbol') {
+    const existingRef = props?.ref;
+    const newProps = {
+      ...props,
+      ref: createSourceRef(source, existingRef),
+    };
+    
+    return OriginalRuntime.jsxDEV(type, newProps, key, isStaticChildren, source, self);
+  }
+  
+  return OriginalRuntime.jsxDEV(type, props, key, isStaticChildren, source, self);
+}
+
+// Re-export everything else from the original runtime
+export const Fragment = OriginalRuntime.Fragment;
+export const jsx = OriginalRuntime.jsx;
+export const jsxs = OriginalRuntime.jsxs;
+`;
+function createJsxSourcePlugin(options) {
+  return {
+    name: "mitway-tagger:jsx-source",
+    enforce: "pre",
+    resolveId(id, importer) {
+      if (id === ORIGINAL_JSX_RUNTIME || id === "\0__original_react_jsx_dev_runtime") {
+        return this.resolve("react/jsx-dev-runtime", importer, { skipSelf: true });
+      }
+      if (id === "react/jsx-dev-runtime") {
+        return RESOLVED_VIRTUAL_JSX_RUNTIME;
+      }
+      if (id === VIRTUAL_JSX_RUNTIME) {
+        return RESOLVED_VIRTUAL_JSX_RUNTIME;
+      }
+      return null;
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_JSX_RUNTIME) {
+        return JSX_RUNTIME_CODE;
+      }
+      return null;
+    },
+    config() {
+      return {
+        // Ensure we're using jsxDEV in development
+        esbuild: {
+          jsx: "automatic",
+          jsxDev: true
+        }
+      };
+    }
+  };
+}
+
+// src/features/virtualOverrides.ts
+import path from "path";
+var virtualOverrides = /* @__PURE__ */ new Map();
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function getAbsolutePath(relativePath, root) {
+  if (path.isAbsolute(relativePath)) {
+    return normalizePath(relativePath);
+  }
+  return normalizePath(path.join(root, relativePath));
+}
+function findModuleByPath(server, filePath) {
+  const normalizedPath = normalizePath(filePath);
+  for (const [, mod] of server.moduleGraph.idToModuleMap) {
+    if (mod.file && normalizePath(mod.file) === normalizedPath) {
+      return mod;
+    }
+  }
+  const variations = [
+    normalizedPath,
+    "/" + normalizedPath,
+    normalizedPath.replace(/^\//, "")
+  ];
+  for (const variation of variations) {
+    const mod = server.moduleGraph.getModuleById(variation);
+    if (mod) return mod;
+  }
+  return void 0;
+}
+async function invalidateModule(server, filePath) {
+  const mod = findModuleByPath(server, filePath);
+  if (mod) {
+    server.moduleGraph.invalidateModule(mod);
+    if (mod.file) {
+      server.ws.send({
+        type: "update",
+        updates: [{
+          type: "js-update",
+          path: mod.url,
+          acceptedPath: mod.url,
+          timestamp: Date.now()
+        }]
+      });
+    }
+    return true;
+  }
+  server.ws.send({ type: "full-reload" });
+  return false;
+}
+function createVirtualOverridesPlugin() {
+  let server;
+  let root;
+  return {
+    name: "mitway-tagger:virtual-overrides",
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root;
+    },
+    configureServer(_server) {
+      server = _server;
+      server.ws.on("mitway:override", async (data) => {
+        const absolutePath = getAbsolutePath(data.path, root);
+        console.log("[mitway-tagger] Setting override for:", absolutePath);
+        virtualOverrides.set(absolutePath, data.content);
+        await invalidateModule(server, absolutePath);
+        server.ws.send("mitway:override-applied", { path: data.path });
+      });
+      server.ws.on("mitway:clear-override", async (data) => {
+        const absolutePath = getAbsolutePath(data.path, root);
+        console.log("[mitway-tagger] Clearing override for:", absolutePath);
+        virtualOverrides.delete(absolutePath);
+        await invalidateModule(server, absolutePath);
+        server.ws.send("mitway:override-cleared", { path: data.path });
+      });
+      server.ws.on("mitway:clear-all-overrides", async () => {
+        console.log("[mitway-tagger] Clearing all overrides");
+        const paths = Array.from(virtualOverrides.keys());
+        virtualOverrides.clear();
+        for (const filePath of paths) {
+          await invalidateModule(server, filePath);
+        }
+        server.ws.send("mitway:all-overrides-cleared", { count: paths.length });
+      });
+      server.ws.on("mitway:get-overrides", () => {
+        const overrides = Array.from(virtualOverrides.entries()).map(([path2, content]) => ({
+          path: path2,
+          contentLength: content.length
+        }));
+        server.ws.send("mitway:overrides-list", { overrides });
+      });
+    },
+    /**
+     * Load hook - serves overridden content if available
+     */
+    load(id) {
+      const normalizedId = normalizePath(id);
+      if (virtualOverrides.has(normalizedId)) {
+        console.log("[mitway-tagger] Serving override for:", normalizedId);
+        return virtualOverrides.get(normalizedId);
+      }
+      const withoutSlash = normalizedId.replace(/^\//, "");
+      if (virtualOverrides.has(withoutSlash)) {
+        console.log("[mitway-tagger] Serving override for:", withoutSlash);
+        return virtualOverrides.get(withoutSlash);
+      }
+      return null;
+    },
+    /**
+     * Transform hook - can be used for additional processing
+     */
+    transform(code, id) {
+      return null;
+    }
+  };
+}
+
+// src/features/visualEditor.ts
+var VISUAL_EDITOR_SCRIPT = `
+<script>
+(function() {
+  'use strict';
+  
+  // State
+  let isSelecting = false;
+  let selectedElement = null;
+  let originalStyles = new Map();
+  let highlightOverlay = null;
+  let selectionOverlay = null;
+  
+  // Create highlight overlay element
+  function createOverlay(id, borderColor) {
+    const overlay = document.createElement('div');
+    overlay.id = id;
+    overlay.style.cssText = \`
+      position: fixed;
+      pointer-events: none;
+      border: 2px solid \${borderColor};
+      background: \${borderColor}10;
+      z-index: 999999;
+      transition: all 0.1s ease;
+      display: none;
+    \`;
+    document.body.appendChild(overlay);
+    return overlay;
+  }
+  
+  // Initialize overlays
+  function initOverlays() {
+    if (!highlightOverlay) {
+      highlightOverlay = createOverlay('mitway-highlight-overlay', '#00BDFF');
+    }
+    if (!selectionOverlay) {
+      selectionOverlay = createOverlay('mitway-selection-overlay', '#00FF88');
+      selectionOverlay.style.border = '2px dashed #00FF88';
+    }
+  }
+  
+  // Position overlay on element
+  function positionOverlay(overlay, element) {
+    if (!overlay || !element) return;
+    const rect = element.getBoundingClientRect();
+    overlay.style.top = rect.top + 'px';
+    overlay.style.left = rect.left + 'px';
+    overlay.style.width = rect.width + 'px';
+    overlay.style.height = rect.height + 'px';
+    overlay.style.display = 'block';
+  }
+  
+  // Hide overlay
+  function hideOverlay(overlay) {
+    if (overlay) {
+      overlay.style.display = 'none';
+    }
+  }
+  
+  // Get XPath for element
+  function getXPath(element) {
+    if (!element) return '';
+    if (element.id) return '//*[@id="' + element.id + '"]';
+    if (element === document.body) return '/html/body';
+    
+    let ix = 0;
+    const siblings = element.parentNode ? element.parentNode.childNodes : [];
+    
+    for (let i = 0; i < siblings.length; i++) {
+      const sibling = siblings[i];
+      if (sibling === element) {
+        const parentPath = getXPath(element.parentNode);
+        const tagName = element.tagName.toLowerCase();
+        return parentPath + '/' + tagName + '[' + (ix + 1) + ']';
+      }
+      if (sibling.nodeType === 1 && sibling.tagName === element.tagName) {
+        ix++;
+      }
+    }
+    return '';
+  }
+  
+  // Get element by XPath
+  function getElementByXPath(xpath) {
+    try {
+      const result = document.evaluate(
+        xpath,
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      return result.singleNodeValue;
+    } catch (e) {
+      return null;
+    }
+  }
+  
+  // Check if element has dynamic styles (className with expressions)
+  function hasDynamicStyles(element) {
+    const classAttr = element.getAttribute('class') || '';
+    return classAttr.includes('\${') || 
+           classAttr.includes('?') || 
+           classAttr.includes('(') ||
+           element.className.includes('[object');
+  }
+  
+  // Get computed styles for element
+  function getElementStyles(element) {
+    const computed = getComputedStyle(element);
+    return {
+      color: computed.color,
+      backgroundColor: computed.backgroundColor,
+      fontSize: computed.fontSize,
+      fontWeight: computed.fontWeight,
+      fontStyle: computed.fontStyle,
+      textAlign: computed.textAlign,
+      marginTop: computed.marginTop,
+      marginRight: computed.marginRight,
+      marginBottom: computed.marginBottom,
+      marginLeft: computed.marginLeft,
+      paddingTop: computed.paddingTop,
+      paddingRight: computed.paddingRight,
+      paddingBottom: computed.paddingBottom,
+      paddingLeft: computed.paddingLeft,
+    };
+  }
+  
+  // Get source info from mitway-tagger jsxSource
+  function getSourceInfo(element) {
+    const SOURCE_SYMBOL = Symbol.for('__mitwaySource__');
+    let current = element;
+    
+    // Walk up the tree to find the first element with source info
+    while (current && current !== document.body) {
+      if (current[SOURCE_SYMBOL]) {
+        return current[SOURCE_SYMBOL];
+      }
+      current = current.parentElement;
+    }
+    
+    return null;
+  }
+  
+  // Get element data for selection
+  function getElementData(element) {
+    const rect = element.getBoundingClientRect();
+    const sourceInfo = getSourceInfo(element);
+    
+    return {
+      tagName: element.tagName,
+      textContent: element.textContent?.trim().substring(0, 500) || '',
+      className: element.className || '',
+      computedStyles: getElementStyles(element),
+      xpath: getXPath(element),
+      rect: {
+        top: rect.top,
+        left: rect.left,
+        width: rect.width,
+        height: rect.height,
+      },
+      hasDynamicStyles: hasDynamicStyles(element),
+      source: sourceInfo ? {
+        fileName: sourceInfo.fileName,
+        lineNumber: sourceInfo.lineNumber,
+        columnNumber: sourceInfo.columnNumber,
+      } : null,
+    };
+  }
+  
+  // Store original inline styles
+  function storeOriginalStyles(element) {
+    if (!originalStyles.has(element)) {
+      originalStyles.set(element, element.getAttribute('style') || '');
+    }
+  }
+  
+  // Apply preview styles to element
+  function applyPreviewStyles(element, styles) {
+    if (!element) return;
+    storeOriginalStyles(element);
+    
+    Object.entries(styles).forEach(([key, value]) => {
+      if (value !== undefined && value !== null && value !== '') {
+        element.style[key] = value;
+      }
+    });
+    
+    if (styles.textContent !== undefined) {
+      element.textContent = styles.textContent;
+    }
+    
+    if (styles.classes !== undefined) {
+      element.className = styles.classes;
+    }
+  }
+  
+  // Restore original styles
+  function restoreOriginalStyles(element) {
+    if (!element) return;
+    const original = originalStyles.get(element);
+    if (original !== undefined) {
+      element.setAttribute('style', original);
+      originalStyles.delete(element);
+    } else {
+      element.removeAttribute('style');
+    }
+  }
+  
+  // Handle mouse move during selection
+  function handleMouseMove(event) {
+    if (!isSelecting) return;
+    
+    const target = event.target;
+    
+    if (target.id === 'mitway-highlight-overlay' || 
+        target.id === 'mitway-selection-overlay' ||
+        target.tagName === 'SCRIPT' ||
+        target.tagName === 'STYLE' ||
+        target.tagName === 'HTML') {
+      return;
+    }
+    
+    positionOverlay(highlightOverlay, target);
+    
+    window.parent?.postMessage({
+      type: 'VISUAL_EDITOR_ELEMENT_HOVER',
+      payload: {
+        tagName: target.tagName,
+        className: target.className,
+      }
+    }, '*');
+  }
+  
+  // Handle click during selection
+  function handleClick(event) {
+    if (!isSelecting) return;
+    
+    event.preventDefault();
+    event.stopPropagation();
+    
+    const target = event.target;
+    
+    if (target.id === 'mitway-highlight-overlay' || 
+        target.id === 'mitway-selection-overlay') {
+      return;
+    }
+    
+    selectedElement = target;
+    isSelecting = false;
+    
+    hideOverlay(highlightOverlay);
+    positionOverlay(selectionOverlay, target);
+    
+    window.parent?.postMessage({
+      type: 'VISUAL_EDITOR_ELEMENT_SELECTED',
+      payload: getElementData(target)
+    }, '*');
+  }
+  
+  // Enable selector mode
+  function enableSelector() {
+    initOverlays();
+    isSelecting = true;
+    selectedElement = null;
+    hideOverlay(selectionOverlay);
+    document.body.style.cursor = 'crosshair';
+    document.addEventListener('mousemove', handleMouseMove, true);
+    document.addEventListener('click', handleClick, true);
+  }
+  
+  // Disable selector mode
+  function disableSelector() {
+    isSelecting = false;
+    selectedElement = null;
+    document.body.style.cursor = '';
+    document.removeEventListener('mousemove', handleMouseMove, true);
+    document.removeEventListener('click', handleClick, true);
+    hideOverlay(highlightOverlay);
+    hideOverlay(selectionOverlay);
+    
+    originalStyles.forEach((_, element) => {
+      restoreOriginalStyles(element);
+    });
+    originalStyles.clear();
+  }
+  
+  // Listen for messages from parent (mITway-App)
+  window.addEventListener('message', (event) => {
+    if (!event.data || typeof event.data.type !== 'string') return;
+    
+    const { type, payload } = event.data;
+    
+    switch (type) {
+      case 'VISUAL_EDITOR_ENABLE_SELECTOR':
+        enableSelector();
+        break;
+        
+      case 'VISUAL_EDITOR_DISABLE_SELECTOR':
+        disableSelector();
+        break;
+        
+      case 'VISUAL_EDITOR_PREVIEW_STYLES':
+        if (payload?.xpath) {
+          const element = getElementByXPath(payload.xpath);
+          if (element) {
+            applyPreviewStyles(element, payload.styles || {});
+          }
+        }
+        break;
+        
+      case 'VISUAL_EDITOR_RESTORE_ORIGINAL':
+        if (payload?.xpath) {
+          const element = getElementByXPath(payload.xpath);
+          if (element) {
+            restoreOriginalStyles(element);
+          }
+        }
+        break;
+    }
+  });
+  
+  // Notify parent that visual editor bridge is ready
+  window.parent?.postMessage({ type: 'VISUAL_EDITOR_BRIDGE_READY' }, '*');
+})();
+</script>`;
+function createVisualEditorPlugin() {
+  return {
+    name: "mitway-tagger:visual-editor",
+    transformIndexHtml(html) {
+      return html.replace("</head>", VISUAL_EDITOR_SCRIPT + "\n</head>");
+    }
+  };
+}
+
+// src/features/iframeNavigation.ts
+var IFRAME_NAVIGATION_SCRIPT = `
+<script>
+(function() {
+  'use strict';
+
+  let lastPath = window.location.pathname + window.location.search + window.location.hash;
+
+  function notifyParent() {
+    const path = window.location.pathname + window.location.search + window.location.hash;
+
+    if (path !== lastPath) {
+      lastPath = path;
+
+      try {
+        window.parent.postMessage({
+          type: 'IFRAME_NAVIGATION',
+          url: path
+        }, '*');
+      } catch (e) {
+        // Silently fail if postMessage is blocked
+      }
+    }
+  }
+
+  // Intercept history methods
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+
+  history.pushState = function() {
+    originalPushState.apply(this, arguments);
+    setTimeout(notifyParent, 0);
+  };
+
+  history.replaceState = function() {
+    originalReplaceState.apply(this, arguments);
+    setTimeout(notifyParent, 0);
+  };
+
+  // Listen to navigation events
+  window.addEventListener('popstate', function() {
+    setTimeout(notifyParent, 0);
+  });
+
+  document.addEventListener('click', function() {
+    setTimeout(notifyParent, 100);
+  }, true);
+
+  // Initial notification
+  setTimeout(notifyParent, 500);
+
+  // Fallback check
+  setInterval(notifyParent, 500);
+
+  // Listen for parent navigation commands
+  window.addEventListener('message', function(event) {
+    if (event.data && event.data.type === 'NAVIGATE_TO') {
+      window.history.pushState(null, '', event.data.url);
+      window.dispatchEvent(new PopStateEvent('popstate'));
+      setTimeout(notifyParent, 0);
+    }
+  });
+})();
+</script>`;
+function createIframeNavigationPlugin() {
+  return {
+    name: "mitway-tagger:iframe-navigation",
+    transformIndexHtml(html) {
+      return html.replace("</body>", `${IFRAME_NAVIGATION_SCRIPT}</body>`);
+    }
+  };
+}
+
+// src/features/themeBridge.ts
+var THEME_BRIDGE_SCRIPT = `
+<script>
+(function() {
+  // Store original CSS variable values for restoration
+  let originalStyles = {};
+  
+  // CSS variables used in the theme
+  // Base variables (without --color- prefix, used in :root)
+  const baseVars = [
+    '--background', '--foreground', '--card', '--card-foreground',
+    '--popover', '--popover-foreground', '--primary', '--primary-foreground',
+    '--secondary', '--secondary-foreground', '--muted', '--muted-foreground',
+    '--accent', '--accent-foreground', '--destructive', '--destructive-foreground',
+    '--border', '--input', '--ring',
+    '--chart-1', '--chart-2', '--chart-3', '--chart-4', '--chart-5',
+    '--sidebar', '--sidebar-foreground', '--sidebar-primary',
+    '--sidebar-primary-foreground', '--sidebar-accent', '--sidebar-accent-foreground',
+    '--sidebar-border', '--sidebar-ring'
+  ];
+  
+  // Radius variables (no hsl wrapper needed)
+  const radiusVars = ['--radius', '--radius-sm', '--radius-md', '--radius-lg', '--radius-xl'];
+  
+  // Capture original styles on first preview
+  function captureOriginalStyles() {
+    if (Object.keys(originalStyles).length > 0) return;
+    const root = document.documentElement;
+    const computed = getComputedStyle(root);
+    [...baseVars, ...radiusVars].forEach(prop => {
+      const value = computed.getPropertyValue(prop).trim();
+      if (value) originalStyles[prop] = value;
+    });
+  }
+  
+  // Check if a value is a radius (not a color)
+  function isRadiusVar(key) {
+    return key.includes('radius');
+  }
+  
+  // Normalize variable name to base format (--background, --primary, etc.)
+  function normalizeVarName(key) {
+    // Remove leading dashes if present
+    let normalized = key.replace(/^-+/, '');
+    
+    // Remove 'color-' prefix if present (convert from Tailwind v4 format)
+    if (normalized.startsWith('color-')) {
+      normalized = normalized.replace('color-', '');
+    }
+    
+    return '--' + normalized;
+  }
+  
+  // Wrap color value with hsl() if needed
+  function wrapWithHsl(value, isRadius) {
+    if (isRadius) return value;
+    
+    // Already has hsl/hsla/rgb/rgba/oklch wrapper
+    if (/^(hsl|hsla|rgb|rgba|oklch)\\(/.test(value)) {
+      return value;
+    }
+    
+    // Wrap with hsl()
+    return 'hsl(' + value + ')';
+  }
+  
+  // Apply theme colors to CSS variables
+  // Values are received WITHOUT hsl() wrapper from mITway-App
+  function applyTheme(theme) {
+    if (!theme) return;
+    const root = document.documentElement;
+    
+    Object.entries(theme).forEach(([key, value]) => {
+      const cssVar = normalizeVarName(key);
+      const isRadius = isRadiusVar(key);
+      const finalValue = wrapWithHsl(value, isRadius);
+      
+      // Set the base variable (--background, --primary, etc.)
+      root.style.setProperty(cssVar, finalValue);
+      
+      // Also set with --color- prefix for @theme inline compatibility
+      if (!isRadius) {
+        const colorVar = '--color-' + cssVar.replace('--', '');
+        root.style.setProperty(colorVar, finalValue);
+      }
+    });
+  }
+  
+  // Restore original CSS variables
+  function restoreOriginal() {
+    const root = document.documentElement;
+    Object.entries(originalStyles).forEach(([key, value]) => {
+      root.style.setProperty(key, value);
+      // Also restore --color- prefixed version
+      if (!isRadiusVar(key)) {
+        const colorVar = '--color-' + key.replace('--', '');
+        root.style.setProperty(colorVar, value);
+      }
+    });
+  }
+  
+  // Listen for theme messages from parent (mITway-App)
+  window.addEventListener('message', (event) => {
+    // Accept messages from any origin (mITway-App domains)
+    if (!event.data || typeof event.data.type !== 'string') return;
+    
+    switch (event.data.type) {
+      case 'PREVIEW_THEME':
+        captureOriginalStyles();
+        applyTheme(event.data.theme);
+        break;
+        
+      case 'RESTORE_THEME':
+        restoreOriginal();
+        break;
+        
+      case 'APPLY_THEME':
+        applyTheme(event.data.theme);
+        // Notify parent that theme was applied
+        window.parent?.postMessage({
+          type: 'THEME_APPLIED',
+          themeId: event.data.themeId
+        }, '*');
+        break;
+    }
+  });
+  
+  // Notify parent that theme bridge is ready
+  window.parent?.postMessage({ type: 'THEME_BRIDGE_READY' }, '*');
+})();
+</script>`;
+function createThemeBridgePlugin() {
+  return {
+    name: "mitway-tagger:theme-bridge",
+    transformIndexHtml(html) {
+      return html.replace("</head>", `${THEME_BRIDGE_SCRIPT}
+</head>`);
+    }
+  };
+}
+
+// src/index.ts
+var defaultOptions = {
+  jsxSource: true,
+  virtualOverrides: true,
+  visualEditor: true,
+  iframeNavigation: true,
+  themeBridge: true,
+  extensions: [".jsx", ".tsx"],
+  exclude: ["node_modules", ".git"]
+};
+function mitwayTagger(options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const plugins = [];
+  if (opts.jsxSource) {
+    plugins.push(createJsxSourcePlugin(opts));
+  }
+  if (opts.virtualOverrides) {
+    plugins.push(createVirtualOverridesPlugin());
+  }
+  if (opts.visualEditor) {
+    plugins.push(createVisualEditorPlugin());
+  }
+  if (opts.iframeNavigation) {
+    plugins.push(createIframeNavigationPlugin());
+  }
+  if (opts.themeBridge) {
+    plugins.push(createThemeBridgePlugin());
+  }
+  return plugins;
+}
+var index_default = mitwayTagger;
+var mitwayServerConfig = {
+  host: "0.0.0.0",
+  port: 80,
+  cors: {
+    origin: [
+      "https://app.nttmitway.com",
+      "https://app.dev.nttmitway.com",
+      "http://app.mitway.local",
+      /^http:\/\/localhost(:\d+)?$/
+    ],
+    methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+    credentials: true
+  },
+  headers: {
+    "Content-Security-Policy": "frame-ancestors https://app.nttmitway.com https://app.dev.nttmitway.com http://app.mitway.local http://localhost:*"
+  },
+  allowedHosts: [".azurecontainerapps.io", ".nttmitway.com"]
+};
+function createmITwayServerConfig(options = {}) {
+  const { additionalOrigins = [], additionalHosts = [], port = 80 } = options;
+  const allOrigins = [...mitwayServerConfig.cors.origin, ...additionalOrigins];
+  const allHosts = [...mitwayServerConfig.allowedHosts, ...additionalHosts];
+  const frameAncestors = allOrigins.filter((o) => typeof o === "string").join(" ");
+  return {
+    host: "0.0.0.0",
+    port,
+    cors: {
+      ...mitwayServerConfig.cors,
+      origin: allOrigins
+    },
+    headers: {
+      "Content-Security-Policy": `frame-ancestors ${frameAncestors} http://localhost:*`
+    },
+    allowedHosts: allHosts
+  };
+}
+export {
+  createIframeNavigationPlugin,
+  createJsxSourcePlugin,
+  createThemeBridgePlugin,
+  createVirtualOverridesPlugin,
+  createVisualEditorPlugin,
+  createmITwayServerConfig,
+  index_default as default,
+  mitwayServerConfig,
+  mitwayTagger
+};