@mints-cloud/cxf-codegen 1.0.0

package/dist/lib/server-props.js

@@ -0,0 +1,353 @@
+"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.PrefetchCollectorContext = exports.EndpointDataContext = void 0;
+exports.normalizeEndpointPath = normalizeEndpointPath;
+exports.buildQueryString = buildQueryString;
+exports.buildEndpointKey = buildEndpointKey;
+exports.PrefetchCollectorProvider = PrefetchCollectorProvider;
+exports.ServerPageWrapper = ServerPageWrapper;
+exports.createServerProps = createServerProps;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const query_1 = require("@plasmicapp/react-web/lib/query");
+const prepass_1 = require("@plasmicapp/react-web/lib/prepass");
+const cxf_auth_1 = require("./cxf-auth");
+const loggedBuildIds = new Set();
+// Context that provides pre-fetched endpoint data to ApiCall components
+// This allows components to skip client-side fetching when data is already available from server-side prefetching
+exports.EndpointDataContext = React.createContext({});
+function normalizeEndpointPath(endpointPath) {
+    const trimmed = String(endpointPath || "").replace(/^\/+|\/+$/g, "");
+    return trimmed || "";
+}
+// Builds a stable, sorted query string from params for consistent cache keys
+function buildQueryString(params) {
+    if (!params || typeof params !== "object" || Array.isArray(params))
+        return "";
+    const usp = new URLSearchParams();
+    Object.keys(params).sort().forEach((k) => {
+        const v = params[k];
+        if (v == null)
+            return;
+        if (Array.isArray(v)) {
+            v.forEach((item) => usp.append(k, String(item)));
+        }
+        else if (typeof v === "object") {
+            usp.append(k, JSON.stringify(v));
+        }
+        else {
+            usp.append(k, String(v));
+        }
+    });
+    const qs = usp.toString();
+    return qs ? `?${qs}` : "";
+}
+// Creates a stable cache key from endpoint path + params
+// Used to match pre-fetched data with component requests
+function buildEndpointKey(endpointPath, params) {
+    const normalizedPath = normalizeEndpointPath(endpointPath);
+    const qs = buildQueryString(params);
+    return qs ? `${normalizedPath}${qs}` : normalizedPath;
+}
+function extractUtmParamsFromQuery(query) {
+    const result = {};
+    if (!query || typeof query !== "object")
+        return result;
+    for (const key of Object.keys(query)) {
+        if (key.toLowerCase().startsWith("utm_")) {
+            result[key] = query[key];
+        }
+    }
+    return result;
+}
+exports.PrefetchCollectorContext = React.createContext(null);
+// Provider that collects prefetch requests during component rendering
+// Used during build-time prepass to discover all API calls
+function PrefetchCollectorProvider({ children, collector, }) {
+    const value = React.useMemo(() => ({ register: (req) => collector.push(req) }), [collector]);
+    return ((0, jsx_runtime_1.jsx)(exports.PrefetchCollectorContext.Provider, { value: value, children: children }));
+}
+/**
+ * Wrapper component that provides pre-fetched data to child components.
+ *
+ * CACHING STRATEGY:
+ * - queryCache: Pre-fetched Plasmic query data (from extractPlasmicQueryData)
+ * - endpointData: Pre-fetched custom endpoint data (from ApiCall)
+ *
+ * Components receive data via React Context, eliminating client-side loading states.
+ * This enables instant page loads with zero API calls on initial render.
+ */
+function ServerPageWrapper({ children, queryCache, endpointData, buildId, buildTimestamp, queriesFound, }) {
+    if (process.env.NODE_ENV !== "production" &&
+        typeof window === "undefined" &&
+        buildId &&
+        !loggedBuildIds.has(buildId)) {
+        loggedBuildIds.add(buildId);
+        console.log("Server Props Debug:", {
+            buildId,
+            buildTime: buildTimestamp,
+            queriesFound,
+            hasCache: !!queryCache,
+            endpointsPreFetched: endpointData ? Object.keys(endpointData).length : 0,
+        });
+    }
+    const hasPrefetchData = !!queryCache && Object.keys(queryCache).length > 0;
+    const hasEndpointData = !!endpointData && Object.keys(endpointData).length > 0;
+    // Provide endpoint data via Context so ApiCall can consume it
+    const wrappedChildren = hasEndpointData ? ((0, jsx_runtime_1.jsx)(exports.EndpointDataContext.Provider, { value: endpointData, children: children })) : (children);
+    // Provide Plasmic query cache for Plasmic components
+    if (hasPrefetchData) {
+        return ((0, jsx_runtime_1.jsx)(query_1.PlasmicQueryDataProvider, { prefetchedCache: queryCache, children: wrappedChildren }));
+    }
+    // Fallback: render without cache (local dev only)
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: wrappedChildren });
+}
+// Unwraps nested { data: {...} } responses from CXF APIs
+function unwrapData(data) {
+    if (data &&
+        typeof data === "object" &&
+        !Array.isArray(data) &&
+        "data" in data &&
+        Object.keys(data).length === 1) {
+        return data.data;
+    }
+    return data;
+}
+// Checks if response indicates auth is required
+function isAuthError(status, error) {
+    return status === 401 || status === 419 ||
+        error?.message?.includes("401") ||
+        error?.message?.includes("419");
+}
+// Fetches data from a URL during build time or SSR
+// Returns null for auth errors (401/419) when cookies aren't available during build
+// Uses makeAuthenticatedRequest when cookies are available (SSR scenarios)
+async function fetchFromUrl(url, options = {}) {
+    const { headers = {}, cookieHeader, apiKey, useAuth = false } = options;
+    try {
+        let resp;
+        // Use authenticated request if cookies are available (SSR scenario)
+        if (useAuth && cookieHeader && apiKey) {
+            try {
+                const { response } = await (0, cxf_auth_1.makeAuthenticatedRequest)(url, {
+                    method: "GET",
+                    cookieHeader,
+                    apiKey,
+                    retryOnAuthError: true,
+                });
+                resp = response;
+            }
+            catch (error) {
+                if (isAuthError(0, error))
+                    return null;
+                throw error;
+            }
+        }
+        else {
+            resp = await fetch(url, { method: "GET", headers });
+        }
+        if (!resp.ok) {
+            if (isAuthError(resp.status))
+                return null;
+            throw new Error(`Request failed (${resp.status})`);
+        }
+        const contentType = resp.headers.get("content-type") || "";
+        const data = contentType.includes("application/json")
+            ? await resp.json()
+            : await resp.text();
+        return unwrapData(data);
+    }
+    catch (error) {
+        if (isAuthError(0, error))
+            return null;
+        throw error;
+    }
+}
+/**
+ * Fetches endpoint data during build time for ISR prerendering or during SSR.
+ *
+ * PREFETCHING STRATEGY:
+ * - Tries upstream CXF API first (using CXF_BASE_URL + API key)
+ * - Falls back to local dev server if upstream unavailable
+ * - When cookies are available (SSR), uses authenticated requests with Contact Auth
+ * - Silently skips auth-protected endpoints (401/419) during build - these fetch at runtime
+ * - Returns null on errors to allow graceful degradation
+ */
+async function fetchEndpointData(endpointPath, params, cookieHeader) {
+    try {
+        const normalizedPath = normalizeEndpointPath(endpointPath);
+        const queryString = buildQueryString(params);
+        // Determine API key type from path
+        const apiKeyType = normalizedPath.startsWith("dev/v1/") ? "dev" :
+            normalizedPath.startsWith("user/v1/") ? "user" : "public";
+        const isCxfApiPath = normalizedPath.startsWith("v1/") ||
+            normalizedPath.startsWith("dev/v1/") ||
+            normalizedPath.startsWith("user/v1/");
+        // Check if we have Contact Auth cookies available
+        const tokens = cookieHeader ? (0, cxf_auth_1.getTokensFromCookies)(cookieHeader) : null;
+        const hasContactAuth = !!(tokens?.accessToken || tokens?.refreshToken);
+        const baseUrl = (0, cxf_auth_1.getCxfBaseUrl)();
+        const apiKey = (0, cxf_auth_1.getCxfApiKey)(apiKeyType);
+        // Build target URL
+        const targetPath = isCxfApiPath ? normalizedPath : `v1/endpoints/${normalizedPath}`;
+        const targetUrl = baseUrl && apiKey
+            ? `${baseUrl.replace(/\/+$/, "")}/api/${targetPath}${queryString}`
+            : `http://localhost:3000/api/${normalizedPath}${queryString}`;
+        // Determine fetch options
+        if (hasContactAuth && apiKey) {
+            return fetchFromUrl(targetUrl, { cookieHeader, apiKey, useAuth: true });
+        }
+        else {
+            const headers = { Accept: "application/json" };
+            if (apiKey)
+                headers["api-key"] = apiKey;
+            return fetchFromUrl(targetUrl, { headers });
+        }
+    }
+    catch (error) {
+        const errorMessage = error?.message || String(error);
+        if (!isAuthError(0, error)) {
+            console.error(`Error fetching endpoint data for ${endpointPath}:`, errorMessage);
+        }
+        return null;
+    }
+}
+/**
+ * Create Next.js data fetching functions with ISR/SSR support.
+ *
+ * PRERENDERING PROCESS:
+ * 1. Renders the Plasmic component to discover all API calls
+ *    - extractPlasmicQueryData: Discovers Plasmic queries
+ *    - PrefetchCollectorProvider: Collects ApiCall requests
+ *
+ * 2. Prefetches all discovered data in parallel
+ *    - Fetches Plasmic query data
+ *    - Fetches custom endpoint data (with Contact Auth when available)
+ *    - Deduplicates requests by cache key
+ *
+ * 3. Returns props with data
+ *    - ISR mode: Caches data with revalidate period (stale-while-revalidate)
+ *    - SSR mode: Returns fresh data on every request
+ *
+ * CACHING BEHAVIOR:
+ * - ISR: Data cached at build time, regenerates in background after revalidate
+ * - SSR: Fresh data on every request, always has access to request cookies
+ */
+function createServerProps(path, PlasmicComponent, options = {}) {
+    const { mode = "isr", revalidate = 60, endpoints = [] } = options;
+    const finalRevalidate = process.env.NODE_ENV === "production" ? revalidate : 60;
+    const isSSR = mode === "ssr";
+    const isDev = process.env.NODE_ENV !== "production";
+    const handler = async (context) => {
+        const buildId = `${isSSR ? "ssr" : "build"}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const buildTimestamp = new Date().toISOString();
+        // Helper to build error props
+        const buildErrorProps = () => ({
+            queryCache: {},
+            buildId,
+            buildTimestamp,
+            queriesFound: 0,
+            _prefetchEnabled: true,
+        });
+        // Helper to build success props
+        const buildProps = (queryCache, endpointData) => {
+            const props = {
+                queryCache: queryCache || {},
+                buildId,
+                buildTimestamp,
+                queriesFound: queryCache ? Object.keys(queryCache).length : 0,
+                _prefetchEnabled: true,
+            };
+            if (Object.keys(endpointData).length > 0) {
+                props.endpointData = endpointData;
+            }
+            return props;
+        };
+        // Helper to return result based on mode
+        const returnResult = (props) => isSSR ? { props } : { props, revalidate: finalRevalidate };
+        try {
+            // Discover API calls by rendering component
+            const collected = [];
+            const element = ((0, jsx_runtime_1.jsx)(PrefetchCollectorProvider, { collector: collected, children: (0, jsx_runtime_1.jsx)(PlasmicComponent, {}) }));
+            const queryCache = await (0, prepass_1.extractPlasmicQueryData)(element);
+            // Debug logging
+            if (isDev) {
+                console.log(`[${isSSR ? "SSR" : "ISR"}] ${path}: Collected ${collected.length} endpoint requests:`, collected.map(c => buildEndpointKey(c.endpointPath, c.params)));
+            }
+            // Merge collected and configured endpoints, then fetch in parallel
+            const merged = [...collected, ...endpoints];
+            const cookieHeader = isSSR
+                ? context.req?.headers?.cookie || null
+                : context.req?.headers?.cookie || null;
+            const utmFromRequest = isSSR ? extractUtmParamsFromQuery(context?.query) : {};
+            const endpointData = {};
+            if (merged.length > 0) {
+                const seen = new Set();
+                const fetchPromises = merged.map(async (cfg) => {
+                    // Merge UTM params from the incoming request; explicit params override UTM values.
+                    const paramsWithUtm = { ...(utmFromRequest || {}), ...(cfg.params || {}) };
+                    const key = buildEndpointKey(cfg.endpointPath, paramsWithUtm);
+                    if (seen.has(key))
+                        return; // Deduplicate
+                    seen.add(key);
+                    const data = await fetchEndpointData(cfg.endpointPath, paramsWithUtm, cookieHeader);
+                    if (data !== null) {
+                        endpointData[key] = data;
+                    }
+                });
+                await Promise.all(fetchPromises);
+            }
+            // Additional debug logging for SSR
+            if (isSSR && isDev) {
+                console.log(`[SSR] ${path}:`, {
+                    endpointsRequested: merged.length,
+                    endpointsFetched: Object.keys(endpointData).length,
+                    hasCookies: !!cookieHeader,
+                    queriesFound: queryCache ? Object.keys(queryCache).length : 0,
+                });
+            }
+            return returnResult(buildProps(queryCache || {}, endpointData));
+        }
+        catch (error) {
+            console.error(`Error extracting Plasmic queries for ${path}:`, error);
+            return returnResult(buildErrorProps());
+        }
+    };
+    // Return object with the appropriate property based on mode
+    return isSSR
+        ? { getServerSideProps: handler }
+        : { getStaticProps: handler };
+}

package/dist/next.config.d.ts

@@ -0,0 +1,9 @@
+import type { NextConfig } from "next";
+type CxfNextConfig = NextConfig & {
+    eslint?: {
+        ignoreDuringBuilds?: boolean;
+    };
+};
+export declare const cxfNextConfig: CxfNextConfig;
+export default cxfNextConfig;
+//# sourceMappingURL=next.config.d.ts.map

package/dist/next.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.config.d.ts","sourceRoot":"","sources":["../src/next.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAEvC,KAAK,aAAa,GAAG,UAAU,GAAG;IAChC,MAAM,CAAC,EAAE;QAAE,kBAAkB,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC3C,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,aAc3B,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/next.config.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cxfNextConfig = void 0;
+exports.cxfNextConfig = {
+    eslint: {
+        ignoreDuringBuilds: true,
+    },
+    trailingSlash: false,
+    reactStrictMode: true,
+    async rewrites() {
+        return [
+            {
+                source: "/assets/:path*",
+                destination: "/api/assets/:path*",
+            },
+        ];
+    },
+};
+exports.default = exports.cxfNextConfig;

package/dist/pages/api/assets.d.ts

@@ -0,0 +1,4 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+export declare function assetsApiHandler(req: NextApiRequest, res: NextApiResponse): Promise<void>;
+export default assetsApiHandler;
+//# sourceMappingURL=assets.d.ts.map

package/dist/pages/api/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../../src/pages/api/assets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAI5D,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,iBA0B/E;AAED,eAAe,gBAAgB,CAAC"}

package/dist/pages/api/assets.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetsApiHandler = assetsApiHandler;
+const cxf_auth_1 = require("../../lib/cxf-auth");
+const api_route_helpers_1 = require("../../lib/api-route-helpers");
+async function assetsApiHandler(req, res) {
+    if (req.method !== "GET") {
+        res.setHeader("Allow", "GET");
+        return res.status(405).json({ error: "Method not allowed" });
+    }
+    try {
+        const baseUrl = (0, cxf_auth_1.getCxfBaseUrl)();
+        const normalizedPath = (0, api_route_helpers_1.normalizePath)(req.query.path);
+        const targetUrl = `${baseUrl}/assets/${normalizedPath}${(0, api_route_helpers_1.buildQueryString)(req.query)}`;
+        const { response, newTokens } = await (0, cxf_auth_1.makeAuthenticatedRequest)(targetUrl, {
+            method: "GET",
+            cookieHeader: req.headers.cookie || null,
+            retryOnAuthError: false,
+        });
+        const setCookieHeaders = (0, cxf_auth_1.extractSetCookieHeaders)(response);
+        const tokens = (0, cxf_auth_1.extractTokensFromSetCookie)(setCookieHeaders);
+        const finalTokens = tokens.accessToken || tokens.refreshToken ? tokens : newTokens;
+        (0, api_route_helpers_1.setAuthCookies)(res, finalTokens);
+        return (0, api_route_helpers_1.sendResponse)(res, response);
+    }
+    catch (err) {
+        return (0, api_route_helpers_1.handleError)(res, err);
+    }
+}
+exports.default = assetsApiHandler;

package/dist/pages/api/cxf.d.ts

@@ -0,0 +1,4 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+export declare function cxfApiHandler(req: NextApiRequest, res: NextApiResponse): Promise<void>;
+export default cxfApiHandler;
+//# sourceMappingURL=cxf.d.ts.map

package/dist/pages/api/cxf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cxf.d.ts","sourceRoot":"","sources":["../../../src/pages/api/cxf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAI5D,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,iBAmD5E;AAED,eAAe,aAAa,CAAC"}

package/dist/pages/api/cxf.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cxfApiHandler = cxfApiHandler;
+const cxf_auth_1 = require("../../lib/cxf-auth");
+const api_route_helpers_1 = require("../../lib/api-route-helpers");
+async function cxfApiHandler(req, res) {
+    const allowedMethods = ["GET", "POST", "PATCH", "PUT", "DELETE"];
+    if (!allowedMethods.includes(req.method || "")) {
+        res.setHeader("Allow", allowedMethods.join(", "));
+        return res.status(405).json({ error: "Method not allowed" });
+    }
+    try {
+        const baseUrl = (0, cxf_auth_1.getCxfBaseUrl)();
+        const normalizedPath = (0, api_route_helpers_1.normalizePath)(req.query.path);
+        const apiKeyType = normalizedPath.startsWith("dev/v1/") ? "dev" :
+            normalizedPath.startsWith("user/v1/") ? "user" : "public";
+        const apiKey = (0, cxf_auth_1.getCxfApiKey)(apiKeyType);
+        if (!apiKey) {
+            const keyNames = { dev: "CXF_DEV_API_KEY", user: "CXF_USER_API_KEY", public: "CXF_API_KEY/API_KEY" };
+            return res.status(500).json({ error: `Missing ${keyNames[apiKeyType]} env var` });
+        }
+        const targetPath = normalizedPath.startsWith("v1/") ||
+            normalizedPath.startsWith("dev/v1/") ||
+            normalizedPath.startsWith("user/v1/")
+            ? normalizedPath
+            : `v1/endpoints/${normalizedPath}`;
+        const targetUrl = `${baseUrl}/api/${targetPath}${(0, api_route_helpers_1.buildQueryString)(req.query)}`;
+        const body = req.method !== "GET" && req.method !== "HEAD" && req.body ? req.body : undefined;
+        const retryOnAuthError = !normalizedPath.match(/^(v1\/(login|register)|dev\/v1\/)/);
+        const { response, newTokens } = await (0, cxf_auth_1.makeAuthenticatedRequest)(targetUrl, {
+            method: req.method || "GET",
+            body,
+            apiKey,
+            userToken: null,
+            cookieHeader: req.headers.cookie || null,
+            retryOnAuthError,
+        });
+        const setCookieHeaders = (0, cxf_auth_1.extractSetCookieHeaders)(response);
+        const tokens = (0, cxf_auth_1.extractTokensFromSetCookie)(setCookieHeaders);
+        const finalTokens = tokens.accessToken || tokens.refreshToken ? tokens : newTokens;
+        (0, api_route_helpers_1.setAuthCookies)(res, finalTokens);
+        return (0, api_route_helpers_1.sendResponse)(res, response);
+    }
+    catch (err) {
+        return (0, api_route_helpers_1.handleError)(res, err);
+    }
+}
+exports.default = cxfApiHandler;

package/dist/pages/app.d.ts

@@ -0,0 +1,4 @@
+import type { AppProps } from "next/app";
+export declare function CxfApp({ Component, pageProps }: AppProps): import("react/jsx-runtime").JSX.Element;
+export default CxfApp;
+//# sourceMappingURL=app.d.ts.map

package/dist/pages/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/pages/app.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAKzC,wBAAgB,MAAM,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,QAAQ,2CA6BxD;AAED,eAAe,MAAM,CAAC"}

package/dist/pages/app.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CxfApp = CxfApp;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_web_1 = require("@plasmicapp/react-web");
+const query_1 = require("@plasmicapp/react-web/lib/query");
+const head_1 = __importDefault(require("next/head"));
+const link_1 = __importDefault(require("next/link"));
+function CxfApp({ Component, pageProps }) {
+    // Detect ISR pages using explicit markers
+    const serverPageProps = pageProps;
+    const isServerPage = Boolean(serverPageProps._prefetchEnabled ||
+        Component.isrEnabled ||
+        serverPageProps.queryCache ||
+        serverPageProps.endpointData);
+    // Fast path: minimal server-side rendering for ISR pages
+    // This bypasses heavy client-side initialization during build time
+    if (typeof window === 'undefined' && isServerPage) {
+        return ((0, jsx_runtime_1.jsx)(react_web_1.PlasmicRootProvider, { Head: head_1.default, Link: link_1.default, children: (0, jsx_runtime_1.jsx)(Component, { ...pageProps }) }));
+    }
+    // Regular path: full initialization for client-side and non-ISR pages
+    // This preserves all functionality for interactive pages
+    return ((0, jsx_runtime_1.jsx)(react_web_1.PlasmicRootProvider, { Head: head_1.default, Link: link_1.default, children: (0, jsx_runtime_1.jsx)(query_1.PlasmicQueryDataProvider, { suspense: true, children: (0, jsx_runtime_1.jsx)(Component, { ...pageProps }) }) }));
+}
+exports.default = CxfApp;

package/dist/pages/plasmic-host.d.ts

@@ -0,0 +1,3 @@
+export declare function PlasmicHost(): import("react/jsx-runtime").JSX.Element;
+export default PlasmicHost;
+//# sourceMappingURL=plasmic-host.d.ts.map

package/dist/pages/plasmic-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plasmic-host.d.ts","sourceRoot":"","sources":["../../src/pages/plasmic-host.tsx"],"names":[],"mappings":"AAUA,wBAAgB,WAAW,4CAE1B;AAED,eAAe,WAAW,CAAC"}

package/dist/pages/plasmic-host.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlasmicHost = PlasmicHost;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const host_1 = require("@plasmicapp/host");
+// You can register any code components that you want to use here; see
+// https://docs.plasmic.app/learn/code-components-ref/
+// And configure your Plasmic project to use the host url pointing at
+// the /plasmic-host page of your nextjs app (for example,
+// http://localhost:3000/plasmic-host).  See
+// https://docs.plasmic.app/learn/app-hosting/#set-a-plasmic-project-to-use-your-app-host
+function PlasmicHost() {
+    return (0, jsx_runtime_1.jsx)(host_1.PlasmicCanvasHost, {});
+}
+exports.default = PlasmicHost;

package/dist/register.d.ts

@@ -0,0 +1,2 @@
+export declare function registerCodeComponents(): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../src/register.ts"],"names":[],"mappings":"AAGA,wBAAgB,sBAAsB,SAmFrC"}

package/dist/register.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCodeComponents = registerCodeComponents;
+const host_1 = require("@plasmicapp/host");
+const ApiCall_1 = require("./components/ApiCall");
+function registerCodeComponents() {
+    (0, host_1.registerComponent)(ApiCall_1.ApiCall, {
+        name: "ApiCall",
+        displayName: "API Call",
+        importName: "ApiCall",
+        importPath: "cxf-codegen/components/ApiCall",
+        section: "CXF",
+        description: "API caller for CXF. Auto-handles path prefixes and auth; provides data via $ctx.response.*. GET auto-fetches; other methods trigger via 'trigger'. If no children, no loading UI.",
+        providesData: true,
+        props: {
+            apiType: {
+                type: "choice",
+                displayName: "API",
+                options: ["endpoint", "contact", "dev", "user"],
+                defaultValue: "contact",
+                description: "Select which API to use. Path should exclude leading version segments.",
+            },
+            path: {
+                type: "string",
+                displayName: "Path",
+                description: "Short path. Example: 'me' or 'blog-posts'.",
+                defaultValue: "me",
+            },
+            method: {
+                type: "choice",
+                displayName: "HTTP Method",
+                options: ["GET", "POST", "PATCH", "PUT", "DELETE"],
+                defaultValue: "GET",
+                description: "GET auto-fetches on mount. POST/PATCH/PUT/DELETE: increment 'trigger' to call.",
+            },
+            params: {
+                type: "object",
+                displayName: "Query Params",
+                description: "Query parameters for GET requests.",
+                defaultValue: {},
+            },
+            body: {
+                type: "object",
+                displayName: "Request Body",
+                description: "Body for POST, PATCH, PUT, DELETE. Can bind form data.",
+                defaultValue: {},
+            },
+            autoFetch: {
+                type: "boolean",
+                displayName: "Auto Fetch",
+                description: "Automatically fetch on mount (default: true for GET, false for others).",
+                advanced: true,
+            },
+            trigger: {
+                type: "number",
+                displayName: "Trigger",
+                description: "Increment this number to trigger non-GET calls.",
+                defaultValue: 0,
+                advanced: false,
+            },
+            onSuccess: {
+                type: "eventHandler",
+                displayName: "On Success",
+                description: "Called when the API call succeeds.",
+                argTypes: [{ name: "data", type: "object" }],
+            },
+            onError: {
+                type: "eventHandler",
+                displayName: "On Error",
+                description: "Called when the API call fails.",
+                argTypes: [{ name: "error", type: "string" }],
+            },
+            loadingContent: {
+                type: "slot",
+                displayName: "Loading content",
+                defaultValue: { type: "text", value: "Loading…" },
+            },
+            children: {
+                type: "slot",
+                displayName: "Content",
+                description: "Content can access $ctx.response.* (data, error, loading, success, failed). If omitted, no loading UI is rendered.",
+                defaultValue: {
+                    type: "text",
+                    value: "Access data via $ctx.response.*",
+                },
+            },
+        },
+    });
+}
+// Auto-register when imported
+registerCodeComponents();