@harpy-js/core 0.4.7

package/dist/core/auto-wrap-middleware.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutoWrapCreateElement = void 0;
+exports.autoWrapIfUsesClient = autoWrapIfUsesClient;
+exports.clearComponentAnalysisCache = clearComponentAnalysisCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const client_component_wrapper_1 = require("./client-component-wrapper");
+const component_analyzer_1 = require("./component-analyzer");
+const componentAnalysisCache = new Map();
+function findComponentSourceFile(component) {
+    try {
+        if (component.__filename) {
+            return component.__filename;
+        }
+        const componentName = component.displayName || component.name;
+        if (!componentName)
+            return null;
+        const srcRoot = path.join(process.cwd(), "src");
+        const viewsDirs = fs.readdirSync(srcRoot).flatMap((feature) => {
+            const viewsPath = path.join(srcRoot, "features", feature, "views");
+            if (fs.existsSync(viewsPath)) {
+                return fs
+                    .readdirSync(viewsPath)
+                    .map((file) => path.join(viewsPath, file));
+            }
+            return [];
+        });
+        const kebabName = componentName
+            .replace(/([A-Z])/g, "-$1")
+            .toLowerCase()
+            .substring(1);
+        return (viewsDirs.find((f) => path.basename(f, path.extname(f)) === kebabName ||
+            path.basename(f, path.extname(f)) === componentName.toLowerCase()) || null);
+    }
+    catch (error) {
+        return null;
+    }
+}
+function hasUseClientDirective(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return /^['"]use client['"];?\s*/.test(content);
+    }
+    catch {
+        return false;
+    }
+}
+function autoWrapIfUsesClient(component) {
+    if (componentAnalysisCache.has(component)) {
+        const cached = componentAnalysisCache.get(component);
+        if (cached.isClientComponent) {
+            return (0, client_component_wrapper_1.autoWrapClientComponent)(component, cached.componentName);
+        }
+        return component;
+    }
+    const sourceFile = findComponentSourceFile(component);
+    if (!sourceFile) {
+        componentAnalysisCache.set(component, {
+            isClientComponent: false,
+            componentName: component.displayName || component.name || "Unknown",
+        });
+        return component;
+    }
+    if (!hasUseClientDirective(sourceFile)) {
+        const componentName = (0, component_analyzer_1.getComponentNameFromPath)(sourceFile);
+        componentAnalysisCache.set(component, {
+            isClientComponent: false,
+            componentName,
+        });
+        return component;
+    }
+    const componentName = (0, component_analyzer_1.getComponentNameFromPath)(sourceFile);
+    componentAnalysisCache.set(component, {
+        isClientComponent: true,
+        componentName,
+    });
+    return (0, client_component_wrapper_1.autoWrapClientComponent)(component, componentName);
+}
+const createAutoWrapCreateElement = (originalCreateElement) => {
+    return (type, props, ...children) => {
+        if (typeof type === "function" && !type.prototype?.isReactComponent) {
+            try {
+                const wrappedType = autoWrapIfUsesClient(type);
+                return originalCreateElement(wrappedType, props, ...children);
+            }
+            catch (error) {
+                return originalCreateElement(type, props, ...children);
+            }
+        }
+        return originalCreateElement(type, props, ...children);
+    };
+};
+exports.createAutoWrapCreateElement = createAutoWrapCreateElement;
+function clearComponentAnalysisCache() {
+    componentAnalysisCache.clear();
+}

package/dist/core/client-component-wrapper.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+declare global {
+    var __COMPONENT_REGISTRY__: ((data: any) => void) | undefined;
+}
+export declare function autoWrapClientComponent<T extends React.ComponentType<any>>(Component: T, componentName: string): React.ComponentType<React.ComponentProps<T>>;

package/dist/core/client-component-wrapper.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoWrapClientComponent = autoWrapClientComponent;
+const react_1 = __importDefault(require("react"));
+function generateInstanceId(prefix) {
+    const randomId = Math.random().toString(36).substring(2, 11);
+    return `${prefix}-${randomId}`;
+}
+function autoWrapClientComponent(Component, componentName) {
+    const WrappedComponent = (props) => {
+        const instanceId = generateInstanceId(`hydrate-${componentName}`);
+        console.log(`[Wrapper] Rendering ${componentName}, registry available:`, typeof global !== "undefined" && !!global.__COMPONENT_REGISTRY__);
+        if (typeof global !== "undefined" && global.__COMPONENT_REGISTRY__) {
+            console.log(`[Wrapper] Registering ${componentName} with id ${instanceId}`);
+            global.__COMPONENT_REGISTRY__({
+                componentPath: "",
+                componentName,
+                instanceId,
+                props: props,
+            });
+        }
+        const propsJson = JSON.stringify(props);
+        return react_1.default.createElement("div", {
+            id: instanceId,
+            suppressHydrationWarning: true,
+        }, react_1.default.createElement(Component, props), react_1.default.createElement("script", {
+            type: "application/json",
+            id: `${instanceId}-props`,
+            dangerouslySetInnerHTML: { __html: propsJson },
+        }));
+    };
+    WrappedComponent.displayName = `ClientComponent(${componentName})`;
+    return WrappedComponent;
+}

package/dist/core/client-hydration.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function hydrateComponent(componentName: string, Component: React.ComponentType<any>): void;

package/dist/core/client-hydration.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateComponent = hydrateComponent;
+const react_1 = __importDefault(require("react"));
+function findHydrationMarkers() {
+    const markers = [];
+    const hydrationDivs = document.querySelectorAll('div[id^="hydrate-"]');
+    hydrationDivs.forEach((div) => {
+        const instanceId = div.id;
+        const match = instanceId.match(/^hydrate-([^-]+)-(.+)$/);
+        if (match) {
+            const componentName = match[1];
+            const propsScriptId = `${instanceId}-props`;
+            markers.push({
+                componentName,
+                instanceId,
+                propsId: propsScriptId,
+            });
+        }
+    });
+    return markers;
+}
+function getHydrationProps(propsId) {
+    const propsScript = document.getElementById(propsId);
+    if (!propsScript)
+        return {};
+    try {
+        return JSON.parse(propsScript.textContent || "{}");
+    }
+    catch (e) {
+        console.warn(`Failed to parse props for ${propsId}:`, e);
+        return {};
+    }
+}
+function hydrateComponent(componentName, Component) {
+    const markers = findHydrationMarkers();
+    const relevantMarkers = markers.filter((m) => m.componentName === componentName);
+    relevantMarkers.forEach((marker) => {
+        const container = document.getElementById(marker.instanceId);
+        if (!container) {
+            console.warn(`Hydration container not found for ${marker.instanceId}`);
+            return;
+        }
+        const props = getHydrationProps(marker.propsId);
+        Promise.all([Promise.resolve().then(() => __importStar(require("react-dom/client")))]).then(([{ hydrateRoot }]) => {
+            try {
+                hydrateRoot(container, react_1.default.createElement(Component, props));
+            }
+            catch (error) {
+                console.error(`Failed to hydrate component ${componentName}:`, error);
+            }
+        });
+    });
+}
+if (typeof window !== "undefined") {
+    window.__HYDRATION__ = { hydrateComponent };
+}

package/dist/core/client-wrapper-browser.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function hydrateClientComponent<T extends React.ComponentType<any>>(Component: T, componentName: string, props: Record<string, any>): React.ReactElement;

package/dist/core/client-wrapper-browser.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateClientComponent = hydrateClientComponent;
+const react_1 = __importDefault(require("react"));
+function generateBrowserInstanceId(prefix) {
+    const randomId = Math.random().toString(36).substring(2, 11);
+    return `${prefix}-${randomId}`;
+}
+function hydrateClientComponent(Component, componentName, props) {
+    const instanceId = generateBrowserInstanceId(`hydrate-${componentName}`);
+    return react_1.default.createElement("div", {
+        id: instanceId,
+        suppressHydrationWarning: true,
+    }, react_1.default.createElement(Component, props), react_1.default.createElement("script", {
+        type: "application/json",
+        id: `${instanceId}-props`,
+        dangerouslySetInnerHTML: { __html: JSON.stringify(props) },
+    }));
+}

package/dist/core/component-analyzer.d.ts

@@ -0,0 +1,4 @@
+export declare function hasUseClientDirective(filePath: string): boolean;
+export declare function getComponentNameFromPath(filePath: string): string;
+export declare function findComponentFiles(dir: string, exclude?: string[]): string[];
+export declare function getClientComponents(srcDir: string): string[];

package/dist/core/component-analyzer.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasUseClientDirective = hasUseClientDirective;
+exports.getComponentNameFromPath = getComponentNameFromPath;
+exports.findComponentFiles = findComponentFiles;
+exports.getClientComponents = getClientComponents;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function hasUseClientDirective(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const useClientRegex = /^(['"]use client['"];?\s*)/m;
+        return useClientRegex.test(content);
+    }
+    catch (error) {
+        console.error(`Error reading file ${filePath}:`, error);
+        return false;
+    }
+}
+function getComponentNameFromPath(filePath) {
+    const fileName = path.basename(filePath, path.extname(filePath));
+    return fileName
+        .split("-")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+function findComponentFiles(dir, exclude = []) {
+    const components = [];
+    function traverse(currentPath) {
+        try {
+            const files = fs.readdirSync(currentPath);
+            for (const file of files) {
+                const fullPath = path.join(currentPath, file);
+                const stat = fs.statSync(fullPath);
+                if (exclude.some((ex) => fullPath.includes(ex))) {
+                    continue;
+                }
+                if (stat.isDirectory()) {
+                    traverse(fullPath);
+                }
+                else if (file.endsWith(".tsx") || file.endsWith(".ts")) {
+                    if (fullPath.includes("/views/") ||
+                        file.endsWith(".component.ts") ||
+                        file.endsWith(".component.tsx")) {
+                        components.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error traversing directory ${currentPath}:`, error);
+        }
+    }
+    traverse(dir);
+    return components;
+}
+function getClientComponents(srcDir) {
+    const components = findComponentFiles(srcDir, [
+        "/node_modules/",
+        "/dist/",
+        "/test/",
+        "/core/",
+    ]);
+    return components.filter((componentPath) => hasUseClientDirective(componentPath));
+}

package/dist/core/component-auto-wrapper.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function autoWrap<T extends React.ComponentType<any>>(Component: T, fileUrl: string): T;

package/dist/core/component-auto-wrapper.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoWrap = autoWrap;
+const fs = __importStar(require("fs"));
+const client_component_wrapper_1 = require("./client-component-wrapper");
+const component_analyzer_1 = require("./component-analyzer");
+const clientComponentCache = new Map();
+function hasUseClientDirective(filePath) {
+    if (clientComponentCache.has(filePath)) {
+        return clientComponentCache.get(filePath);
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const hasDirective = /^(['"]use client['"];?\s*)/m.test(content);
+        clientComponentCache.set(filePath, hasDirective);
+        return hasDirective;
+    }
+    catch (error) {
+        clientComponentCache.set(filePath, false);
+        return false;
+    }
+}
+function autoWrap(Component, fileUrl) {
+    const filePath = fileUrl.replace("file://", "");
+    if (!hasUseClientDirective(filePath)) {
+        return Component;
+    }
+    const componentName = (0, component_analyzer_1.getComponentNameFromPath)(filePath);
+    return (0, client_component_wrapper_1.autoWrapClientComponent)(Component, componentName);
+}

package/dist/core/component-client-wrapper.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare function createClientComponent<T extends React.ComponentType<any>>(Component: T, sourceFile: string): T;
+export declare function autoWrapIfClient<T extends React.ComponentType<any>>(Component: T, filename: string): T;
+export declare function clearComponentCache(): void;

package/dist/core/component-client-wrapper.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientComponent = createClientComponent;
+exports.autoWrapIfClient = autoWrapIfClient;
+exports.clearComponentCache = clearComponentCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const client_component_wrapper_1 = require("./client-component-wrapper");
+const component_analyzer_1 = require("./component-analyzer");
+const componentCache = new Map();
+function detectClientComponent(sourceFilePath) {
+    const normalizedPath = path.resolve(sourceFilePath);
+    if (componentCache.has(normalizedPath)) {
+        const cached = componentCache.get(normalizedPath);
+        return {
+            isClientComponent: cached.isClientComponent,
+            componentPath: normalizedPath,
+        };
+    }
+    let isClientComponent = false;
+    try {
+        const content = fs.readFileSync(normalizedPath, "utf-8");
+        isClientComponent = /^['"]use client['"];?\s*/.test(content);
+    }
+    catch (error) {
+        isClientComponent = false;
+    }
+    componentCache.set(normalizedPath, {
+        isClientComponent,
+        wrappedComponent: null,
+    });
+    return { isClientComponent, componentPath: normalizedPath };
+}
+function createClientComponent(Component, sourceFile) {
+    const { isClientComponent, componentPath } = detectClientComponent(sourceFile);
+    if (!isClientComponent) {
+        return Component;
+    }
+    const componentName = (0, component_analyzer_1.getComponentNameFromPath)(componentPath);
+    return (0, client_component_wrapper_1.autoWrapClientComponent)(Component, componentName);
+}
+function autoWrapIfClient(Component, filename) {
+    return createClientComponent(Component, filename);
+}
+function clearComponentCache() {
+    componentCache.clear();
+}

package/dist/core/hydration-generator.d.ts

@@ -0,0 +1,2 @@
+export declare function generateHydrationEntryFiles(srcDir: string, outputDir: string): string[];
+export declare function getHydrationEntryFiles(outputDir: string): string[];

package/dist/core/hydration-generator.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHydrationEntryFiles = generateHydrationEntryFiles;
+exports.getHydrationEntryFiles = getHydrationEntryFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const component_analyzer_1 = require("./component-analyzer");
+function generateHydrationEntryFiles(srcDir, outputDir) {
+    const clientComponentPaths = (0, component_analyzer_1.getClientComponents)(srcDir);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const entryFiles = [];
+    for (const componentPath of clientComponentPaths) {
+        const componentName = (0, component_analyzer_1.getComponentNameFromPath)(componentPath);
+        const relativePath = path.relative(srcDir, componentPath);
+        const fromAssets = path.join(outputDir, "dummy.ts");
+        let importPath = path.relative(path.dirname(fromAssets), componentPath);
+        importPath = importPath.replace(/\\/g, "/");
+        importPath = importPath.replace(/\.tsx?$/, "");
+        const entryFileName = `${componentName}.ts`;
+        const entryFilePath = path.join(outputDir, entryFileName);
+        const entryContent = `
+import { hydrateRoot } from 'react-dom/client';
+import * as React from 'react';
+
+// Import the client component
+import ${componentName} from '${importPath}';
+
+/**
+ * Auto-generated hydration entry for ${componentName}
+ * This file is bundled separately to reduce the main bundle size
+ */
+
+// Find all instances of this component marked with data-hydration-id
+const instances = document.querySelectorAll('[data-hydration-id]');
+
+instances.forEach((element) => {
+  const hydrationId = element.getAttribute('data-hydration-id');
+  if (hydrationId) {
+    try {
+      // Hydrate the component
+      hydrateRoot(element, React.createElement(${componentName}));
+      console.log('[Hydration] Successfully hydrated ${componentName} (id: ' + hydrationId + ')');
+    } catch (error) {
+      console.error('[Hydration] Failed to hydrate ${componentName}:', error);
+    }
+  }
+});
+`.trim();
+        fs.writeFileSync(entryFilePath, entryContent, "utf-8");
+        entryFiles.push(entryFilePath);
+        console.log(`Generated hydration entry: ${entryFileName}`);
+    }
+    return entryFiles;
+}
+function getHydrationEntryFiles(outputDir) {
+    if (!fs.existsSync(outputDir)) {
+        return [];
+    }
+    return fs
+        .readdirSync(outputDir)
+        .filter((file) => file.endsWith(".ts") && !file.endsWith(".spec.ts"))
+        .map((file) => path.join(outputDir, file));
+}

package/dist/core/hydration-manifest.d.ts

@@ -0,0 +1,7 @@
+export interface HydrationManifest {
+    [componentName: string]: string;
+}
+export declare function getHydrationManifest(): HydrationManifest;
+export declare function getChunkFileName(componentName: string): string | null;
+export declare function getChunkPath(componentName: string): string | null;
+export declare function invalidateManifestCache(): void;