@replanejs/next 0.7.3 → 0.7.6

package/dist/server.cjs

@@ -1,95 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const __replanejs_sdk = require_chunk.__toESM(require("@replanejs/sdk"));
-
-//#region src/server.ts
-/**
-* Fetch configs from Replane and return a serializable snapshot.
-*
-* This is the primary server-side function for Next.js integration.
-* It creates a Replane client, waits for initialization, captures a snapshot,
-* and closes the client.
-*
-* The snapshot can be passed to `ReplaneNextProvider` for client-side hydration.
-*
-* @example
-* ```tsx
-* // In a Server Component
-* const snapshot = await getReplaneSnapshot({
-*   baseUrl: process.env.REPLANE_BASE_URL!,
-*   sdkKey: process.env.REPLANE_SDK_KEY!,
-*   context: { userId: user.id },
-* });
-* ```
-*
-* @example
-* ```tsx
-* // With Next.js caching
-* const snapshot = await getReplaneSnapshot({
-*   baseUrl: process.env.REPLANE_BASE_URL!,
-*   sdkKey: process.env.REPLANE_SDK_KEY!,
-*   fetchFn: (url, init) => fetch(url, {
-*     ...init,
-*     next: { revalidate: 60 }, // Revalidate every 60 seconds
-*   }),
-* });
-* ```
-*/
-async function getReplaneSnapshot(options) {
-	const client = await (0, __replanejs_sdk.createReplaneClient)({
-		baseUrl: options.baseUrl,
-		sdkKey: options.sdkKey,
-		fetchFn: options.fetchFn,
-		requestTimeoutMs: options.requestTimeoutMs,
-		initializationTimeoutMs: options.initializationTimeoutMs,
-		context: options.context,
-		required: options.required,
-		fallbacks: options.fallbacks
-	});
-	try {
-		return client.getSnapshot();
-	} finally {
-		client.close();
-	}
-}
-/**
-* Get a config value directly on the server.
-*
-* This is useful when you need a single config value in a Server Component
-* or server-side code and don't need the full snapshot/hydration flow.
-*
-* Note: This creates a new client for each call, so prefer `getReplaneSnapshot`
-* if you need multiple configs or client-side hydration.
-*
-* @example
-* ```tsx
-* // In a Server Component
-* const maintenanceMode = await getConfig<boolean>({
-*   name: "maintenance-mode",
-*   baseUrl: process.env.REPLANE_BASE_URL!,
-*   sdkKey: process.env.REPLANE_SDK_KEY!,
-* });
-*
-* if (maintenanceMode) {
-*   return <MaintenancePage />;
-* }
-* ```
-*/
-async function getConfig(options) {
-	const client = await (0, __replanejs_sdk.createReplaneClient)({
-		baseUrl: options.baseUrl,
-		sdkKey: options.sdkKey,
-		fetchFn: options.fetchFn,
-		requestTimeoutMs: options.requestTimeoutMs,
-		initializationTimeoutMs: options.initializationTimeoutMs,
-		context: options.context
-	});
-	try {
-		return client.get(options.name, { context: options.context });
-	} finally {
-		client.close();
-	}
-}
-
-//#endregion
-exports.getConfig = getConfig;
-exports.getReplaneSnapshot = getReplaneSnapshot;

package/dist/server.d.cts

@@ -1,114 +0,0 @@
-import { ReplaneClientOptions, ReplaneContext, ReplaneSnapshot } from "@replanejs/sdk";
-
-//#region src/server.d.ts
-
-interface GetReplaneSnapshotOptions<T extends object = Record<string, unknown>> {
-  /**
-   * Base URL of the Replane instance (no trailing slash).
-   */
-  baseUrl: string;
-  /**
-   * Project SDK key for authorization.
-   */
-  sdkKey: string;
-  /**
-   * Custom fetch implementation (useful for caching configuration).
-   * In Next.js, you can use the fetch options for caching:
-   * ```ts
-   * fetchFn: (url, init) => fetch(url, { ...init, next: { revalidate: 60 } })
-   * ```
-   */
-  fetchFn?: typeof fetch;
-  /**
-   * Optional timeout in ms for the request.
-   * @default 2000
-   */
-  requestTimeoutMs?: number;
-  /**
-   * Optional timeout in ms for initialization.
-   * @default 5000
-   */
-  initializationTimeoutMs?: number;
-  /**
-   * Default context used for override evaluation.
-   * This context will be included in the snapshot.
-   */
-  context?: ReplaneContext;
-  /**
-   * Config names that must be present before the client is ready.
-   */
-  required?: ReplaneClientOptions<T>["required"];
-  /**
-   * Fallback values to use if configs are not available.
-   */
-  fallbacks?: ReplaneClientOptions<T>["fallbacks"];
-}
-/**
- * Fetch configs from Replane and return a serializable snapshot.
- *
- * This is the primary server-side function for Next.js integration.
- * It creates a Replane client, waits for initialization, captures a snapshot,
- * and closes the client.
- *
- * The snapshot can be passed to `ReplaneNextProvider` for client-side hydration.
- *
- * @example
- * ```tsx
- * // In a Server Component
- * const snapshot = await getReplaneSnapshot({
- *   baseUrl: process.env.REPLANE_BASE_URL!,
- *   sdkKey: process.env.REPLANE_SDK_KEY!,
- *   context: { userId: user.id },
- * });
- * ```
- *
- * @example
- * ```tsx
- * // With Next.js caching
- * const snapshot = await getReplaneSnapshot({
- *   baseUrl: process.env.REPLANE_BASE_URL!,
- *   sdkKey: process.env.REPLANE_SDK_KEY!,
- *   fetchFn: (url, init) => fetch(url, {
- *     ...init,
- *     next: { revalidate: 60 }, // Revalidate every 60 seconds
- *   }),
- * });
- * ```
- */
-declare function getReplaneSnapshot<T extends object = Record<string, unknown>>(options: GetReplaneSnapshotOptions<T>): Promise<ReplaneSnapshot<T>>;
-/**
- * Get a config value directly on the server.
- *
- * This is useful when you need a single config value in a Server Component
- * or server-side code and don't need the full snapshot/hydration flow.
- *
- * Note: This creates a new client for each call, so prefer `getReplaneSnapshot`
- * if you need multiple configs or client-side hydration.
- *
- * @example
- * ```tsx
- * // In a Server Component
- * const maintenanceMode = await getConfig<boolean>({
- *   name: "maintenance-mode",
- *   baseUrl: process.env.REPLANE_BASE_URL!,
- *   sdkKey: process.env.REPLANE_SDK_KEY!,
- * });
- *
- * if (maintenanceMode) {
- *   return <MaintenancePage />;
- * }
- * ```
- */
-declare function getConfig<T>(options: {
-  name: string;
-  baseUrl: string;
-  sdkKey: string;
-  fetchFn?: typeof fetch;
-  requestTimeoutMs?: number;
-  initializationTimeoutMs?: number;
-  context?: ReplaneContext;
-}): Promise<T>;
-//# sourceMappingURL=server.d.ts.map
-//#endregion
-export { GetReplaneSnapshotOptions, type ReplaneContext, type ReplaneSnapshot, getConfig, getReplaneSnapshot };
-//# sourceMappingURL=server.d.cts.map

package/dist/server.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.cts","names":[],"sources":["../src/server.ts"],"sourcesContent":[],"mappings":";;;;UAiDiB,6CAA6C;;;;;;;;;;;;;;;;mBAkB3C;;;;;;;;;;;;;;;YAkBP;;;;aAKC,qBAAqB;;;;cAKpB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCb,sCAAsC,kCACjD,0BAA0B,KAClC,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;iBA0CL;;;;mBAIH;;;YAGP;IACR,QAAQ"}

package/dist/server.d.ts

@@ -1,114 +0,0 @@
-import { ReplaneClientOptions, ReplaneContext, ReplaneSnapshot } from "@replanejs/sdk";
-
-//#region src/server.d.ts
-
-interface GetReplaneSnapshotOptions<T extends object = Record<string, unknown>> {
-  /**
-   * Base URL of the Replane instance (no trailing slash).
-   */
-  baseUrl: string;
-  /**
-   * Project SDK key for authorization.
-   */
-  sdkKey: string;
-  /**
-   * Custom fetch implementation (useful for caching configuration).
-   * In Next.js, you can use the fetch options for caching:
-   * ```ts
-   * fetchFn: (url, init) => fetch(url, { ...init, next: { revalidate: 60 } })
-   * ```
-   */
-  fetchFn?: typeof fetch;
-  /**
-   * Optional timeout in ms for the request.
-   * @default 2000
-   */
-  requestTimeoutMs?: number;
-  /**
-   * Optional timeout in ms for initialization.
-   * @default 5000
-   */
-  initializationTimeoutMs?: number;
-  /**
-   * Default context used for override evaluation.
-   * This context will be included in the snapshot.
-   */
-  context?: ReplaneContext;
-  /**
-   * Config names that must be present before the client is ready.
-   */
-  required?: ReplaneClientOptions<T>["required"];
-  /**
-   * Fallback values to use if configs are not available.
-   */
-  fallbacks?: ReplaneClientOptions<T>["fallbacks"];
-}
-/**
- * Fetch configs from Replane and return a serializable snapshot.
- *
- * This is the primary server-side function for Next.js integration.
- * It creates a Replane client, waits for initialization, captures a snapshot,
- * and closes the client.
- *
- * The snapshot can be passed to `ReplaneNextProvider` for client-side hydration.
- *
- * @example
- * ```tsx
- * // In a Server Component
- * const snapshot = await getReplaneSnapshot({
- *   baseUrl: process.env.REPLANE_BASE_URL!,
- *   sdkKey: process.env.REPLANE_SDK_KEY!,
- *   context: { userId: user.id },
- * });
- * ```
- *
- * @example
- * ```tsx
- * // With Next.js caching
- * const snapshot = await getReplaneSnapshot({
- *   baseUrl: process.env.REPLANE_BASE_URL!,
- *   sdkKey: process.env.REPLANE_SDK_KEY!,
- *   fetchFn: (url, init) => fetch(url, {
- *     ...init,
- *     next: { revalidate: 60 }, // Revalidate every 60 seconds
- *   }),
- * });
- * ```
- */
-declare function getReplaneSnapshot<T extends object = Record<string, unknown>>(options: GetReplaneSnapshotOptions<T>): Promise<ReplaneSnapshot<T>>;
-/**
- * Get a config value directly on the server.
- *
- * This is useful when you need a single config value in a Server Component
- * or server-side code and don't need the full snapshot/hydration flow.
- *
- * Note: This creates a new client for each call, so prefer `getReplaneSnapshot`
- * if you need multiple configs or client-side hydration.
- *
- * @example
- * ```tsx
- * // In a Server Component
- * const maintenanceMode = await getConfig<boolean>({
- *   name: "maintenance-mode",
- *   baseUrl: process.env.REPLANE_BASE_URL!,
- *   sdkKey: process.env.REPLANE_SDK_KEY!,
- * });
- *
- * if (maintenanceMode) {
- *   return <MaintenancePage />;
- * }
- * ```
- */
-declare function getConfig<T>(options: {
-  name: string;
-  baseUrl: string;
-  sdkKey: string;
-  fetchFn?: typeof fetch;
-  requestTimeoutMs?: number;
-  initializationTimeoutMs?: number;
-  context?: ReplaneContext;
-}): Promise<T>;
-//# sourceMappingURL=server.d.ts.map
-//#endregion
-export { GetReplaneSnapshotOptions, type ReplaneContext, type ReplaneSnapshot, getConfig, getReplaneSnapshot };
-//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"sourcesContent":[],"mappings":";;;;UAiDiB,6CAA6C;;;;;;;;;;;;;;;;mBAkB3C;;;;;;;;;;;;;;;YAkBP;;;;aAKC,qBAAqB;;;;cAKpB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCb,sCAAsC,kCACjD,0BAA0B,KAClC,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;iBA0CL;;;;mBAIH;;;YAGP;IACR,QAAQ"}

package/dist/server.js

@@ -1,94 +0,0 @@
-import { createReplaneClient } from "@replanejs/sdk";
-
-//#region src/server.ts
-/**
-* Fetch configs from Replane and return a serializable snapshot.
-*
-* This is the primary server-side function for Next.js integration.
-* It creates a Replane client, waits for initialization, captures a snapshot,
-* and closes the client.
-*
-* The snapshot can be passed to `ReplaneNextProvider` for client-side hydration.
-*
-* @example
-* ```tsx
-* // In a Server Component
-* const snapshot = await getReplaneSnapshot({
-*   baseUrl: process.env.REPLANE_BASE_URL!,
-*   sdkKey: process.env.REPLANE_SDK_KEY!,
-*   context: { userId: user.id },
-* });
-* ```
-*
-* @example
-* ```tsx
-* // With Next.js caching
-* const snapshot = await getReplaneSnapshot({
-*   baseUrl: process.env.REPLANE_BASE_URL!,
-*   sdkKey: process.env.REPLANE_SDK_KEY!,
-*   fetchFn: (url, init) => fetch(url, {
-*     ...init,
-*     next: { revalidate: 60 }, // Revalidate every 60 seconds
-*   }),
-* });
-* ```
-*/
-async function getReplaneSnapshot(options) {
-	const client = await createReplaneClient({
-		baseUrl: options.baseUrl,
-		sdkKey: options.sdkKey,
-		fetchFn: options.fetchFn,
-		requestTimeoutMs: options.requestTimeoutMs,
-		initializationTimeoutMs: options.initializationTimeoutMs,
-		context: options.context,
-		required: options.required,
-		fallbacks: options.fallbacks
-	});
-	try {
-		return client.getSnapshot();
-	} finally {
-		client.close();
-	}
-}
-/**
-* Get a config value directly on the server.
-*
-* This is useful when you need a single config value in a Server Component
-* or server-side code and don't need the full snapshot/hydration flow.
-*
-* Note: This creates a new client for each call, so prefer `getReplaneSnapshot`
-* if you need multiple configs or client-side hydration.
-*
-* @example
-* ```tsx
-* // In a Server Component
-* const maintenanceMode = await getConfig<boolean>({
-*   name: "maintenance-mode",
-*   baseUrl: process.env.REPLANE_BASE_URL!,
-*   sdkKey: process.env.REPLANE_SDK_KEY!,
-* });
-*
-* if (maintenanceMode) {
-*   return <MaintenancePage />;
-* }
-* ```
-*/
-async function getConfig(options) {
-	const client = await createReplaneClient({
-		baseUrl: options.baseUrl,
-		sdkKey: options.sdkKey,
-		fetchFn: options.fetchFn,
-		requestTimeoutMs: options.requestTimeoutMs,
-		initializationTimeoutMs: options.initializationTimeoutMs,
-		context: options.context
-	});
-	try {
-		return client.get(options.name, { context: options.context });
-	} finally {
-		client.close();
-	}
-}
-
-//#endregion
-export { getConfig, getReplaneSnapshot };
-//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.js","names":["options: GetReplaneSnapshotOptions<T>","options: {\n  name: string;\n  baseUrl: string;\n  sdkKey: string;\n  fetchFn?: typeof fetch;\n  requestTimeoutMs?: number;\n  initializationTimeoutMs?: number;\n  context?: ReplaneContext;\n}"],"sources":["../src/server.ts"],"sourcesContent":["/**\n * Server-side utilities for Replane in Next.js.\n *\n * These functions are designed to be used in:\n * - React Server Components (RSC)\n * - getServerSideProps\n * - API routes\n * - Server Actions\n *\n * @example\n * ```tsx\n * // app/layout.tsx (Server Component)\n * import { getReplaneSnapshot } from \"@replanejs/next/server\";\n * import { ReplaneNextProvider } from \"@replanejs/next\";\n *\n * export default async function RootLayout({ children }) {\n *   const snapshot = await getReplaneSnapshot({\n *     baseUrl: process.env.REPLANE_BASE_URL!,\n *     sdkKey: process.env.REPLANE_SDK_KEY!,\n *   });\n *\n *   return (\n *     <html>\n *       <body>\n *         <ReplaneNextProvider\n *           snapshot={snapshot}\n *           connection={{\n *             baseUrl: process.env.NEXT_PUBLIC_REPLANE_BASE_URL!,\n *             sdkKey: process.env.NEXT_PUBLIC_REPLANE_SDK_KEY!,\n *           }}\n *         >\n *           {children}\n *         </ReplaneNextProvider>\n *       </body>\n *     </html>\n *   );\n * }\n * ```\n */\n\nimport {\n  createReplaneClient,\n  type ReplaneClientOptions,\n  type ReplaneSnapshot,\n  type ReplaneContext,\n} from \"@replanejs/sdk\";\n\nexport type { ReplaneSnapshot, ReplaneContext };\n\nexport interface GetReplaneSnapshotOptions<T extends object = Record<string, unknown>> {\n  /**\n   * Base URL of the Replane instance (no trailing slash).\n   */\n  baseUrl: string;\n\n  /**\n   * Project SDK key for authorization.\n   */\n  sdkKey: string;\n\n  /**\n   * Custom fetch implementation (useful for caching configuration).\n   * In Next.js, you can use the fetch options for caching:\n   * ```ts\n   * fetchFn: (url, init) => fetch(url, { ...init, next: { revalidate: 60 } })\n   * ```\n   */\n  fetchFn?: typeof fetch;\n\n  /**\n   * Optional timeout in ms for the request.\n   * @default 2000\n   */\n  requestTimeoutMs?: number;\n\n  /**\n   * Optional timeout in ms for initialization.\n   * @default 5000\n   */\n  initializationTimeoutMs?: number;\n\n  /**\n   * Default context used for override evaluation.\n   * This context will be included in the snapshot.\n   */\n  context?: ReplaneContext;\n\n  /**\n   * Config names that must be present before the client is ready.\n   */\n  required?: ReplaneClientOptions<T>[\"required\"];\n\n  /**\n   * Fallback values to use if configs are not available.\n   */\n  fallbacks?: ReplaneClientOptions<T>[\"fallbacks\"];\n}\n\n/**\n * Fetch configs from Replane and return a serializable snapshot.\n *\n * This is the primary server-side function for Next.js integration.\n * It creates a Replane client, waits for initialization, captures a snapshot,\n * and closes the client.\n *\n * The snapshot can be passed to `ReplaneNextProvider` for client-side hydration.\n *\n * @example\n * ```tsx\n * // In a Server Component\n * const snapshot = await getReplaneSnapshot({\n *   baseUrl: process.env.REPLANE_BASE_URL!,\n *   sdkKey: process.env.REPLANE_SDK_KEY!,\n *   context: { userId: user.id },\n * });\n * ```\n *\n * @example\n * ```tsx\n * // With Next.js caching\n * const snapshot = await getReplaneSnapshot({\n *   baseUrl: process.env.REPLANE_BASE_URL!,\n *   sdkKey: process.env.REPLANE_SDK_KEY!,\n *   fetchFn: (url, init) => fetch(url, {\n *     ...init,\n *     next: { revalidate: 60 }, // Revalidate every 60 seconds\n *   }),\n * });\n * ```\n */\nexport async function getReplaneSnapshot<T extends object = Record<string, unknown>>(\n  options: GetReplaneSnapshotOptions<T>\n): Promise<ReplaneSnapshot<T>> {\n  const client = await createReplaneClient<T>({\n    baseUrl: options.baseUrl,\n    sdkKey: options.sdkKey,\n    fetchFn: options.fetchFn,\n    requestTimeoutMs: options.requestTimeoutMs,\n    initializationTimeoutMs: options.initializationTimeoutMs,\n    context: options.context,\n    required: options.required,\n    fallbacks: options.fallbacks,\n  });\n\n  try {\n    return client.getSnapshot();\n  } finally {\n    client.close();\n  }\n}\n\n/**\n * Get a config value directly on the server.\n *\n * This is useful when you need a single config value in a Server Component\n * or server-side code and don't need the full snapshot/hydration flow.\n *\n * Note: This creates a new client for each call, so prefer `getReplaneSnapshot`\n * if you need multiple configs or client-side hydration.\n *\n * @example\n * ```tsx\n * // In a Server Component\n * const maintenanceMode = await getConfig<boolean>({\n *   name: \"maintenance-mode\",\n *   baseUrl: process.env.REPLANE_BASE_URL!,\n *   sdkKey: process.env.REPLANE_SDK_KEY!,\n * });\n *\n * if (maintenanceMode) {\n *   return <MaintenancePage />;\n * }\n * ```\n */\nexport async function getConfig<T>(options: {\n  name: string;\n  baseUrl: string;\n  sdkKey: string;\n  fetchFn?: typeof fetch;\n  requestTimeoutMs?: number;\n  initializationTimeoutMs?: number;\n  context?: ReplaneContext;\n}): Promise<T> {\n  const client = await createReplaneClient({\n    baseUrl: options.baseUrl,\n    sdkKey: options.sdkKey,\n    fetchFn: options.fetchFn,\n    requestTimeoutMs: options.requestTimeoutMs,\n    initializationTimeoutMs: options.initializationTimeoutMs,\n    context: options.context,\n  });\n\n  try {\n    return client.get(options.name, { context: options.context }) as T;\n  } finally {\n    client.close();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,eAAsB,mBACpBA,SAC6B;CAC7B,MAAM,SAAS,MAAM,oBAAuB;EAC1C,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,SAAS,QAAQ;EACjB,kBAAkB,QAAQ;EAC1B,yBAAyB,QAAQ;EACjC,SAAS,QAAQ;EACjB,UAAU,QAAQ;EAClB,WAAW,QAAQ;CACpB,EAAC;AAEF,KAAI;AACF,SAAO,OAAO,aAAa;CAC5B,UAAS;AACR,SAAO,OAAO;CACf;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBD,eAAsB,UAAaC,SAQpB;CACb,MAAM,SAAS,MAAM,oBAAoB;EACvC,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,SAAS,QAAQ;EACjB,kBAAkB,QAAQ;EAC1B,yBAAyB,QAAQ;EACjC,SAAS,QAAQ;CAClB,EAAC;AAEF,KAAI;AACF,SAAO,OAAO,IAAI,QAAQ,MAAM,EAAE,SAAS,QAAQ,QAAS,EAAC;CAC9D,UAAS;AACR,SAAO,OAAO;CACf;AACF"}