hadars 0.1.16 → 0.1.18

package/dist/index.cjs

@@ -30,8 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.tsx
 var src_exports = {};
 __export(src_exports, {
+  CacheSegment: () => CacheSegment,
   HadarsContext: () => HadarsContext,
   HadarsHead: () => Head,
+  clearSegments: () => clearSegments,
+  deleteSegment: () => deleteSegment,
   initServerDataCache: () => initServerDataCache,
   loadModule: () => loadModule,
   useServerData: () => useServerData
@@ -216,8 +219,7 @@ function useServerData(key, fn) {
           }
         );
         unsuspend.cache.set(cacheKey, { status: "pending", promise: suspensePromise });
-        unsuspend.hasPending = true;
-        return void 0;
+        throw suspensePromise;
       }
       throw thrown;
     }
@@ -236,12 +238,10 @@ function useServerData(key, fn) {
       }
     );
     unsuspend.cache.set(cacheKey, { status: "pending", promise });
-    unsuspend.hasPending = true;
-    return void 0;
+    throw promise;
   }
   if (existing.status === "pending") {
-    unsuspend.hasPending = true;
-    return void 0;
+    throw existing.promise;
   }
   if (existing.status === "rejected")
     throw existing.reason;
@@ -298,6 +298,58 @@ var Head = import_react.default.memo(({ children, status }) => {
   return null;
 });
 
+// src/components/CacheSegment.tsx
+var import_react2 = __toESM(require("react"), 1);
+
+// src/utils/segmentCache.ts
+function getStore() {
+  const g = globalThis;
+  if (!g.__hadarsSegmentStore) {
+    g.__hadarsSegmentStore = /* @__PURE__ */ new Map();
+  }
+  return g.__hadarsSegmentStore;
+}
+function getSegment(key) {
+  const entry = getStore().get(key);
+  if (!entry)
+    return null;
+  if (entry.expiresAt !== null && Date.now() >= entry.expiresAt) {
+    getStore().delete(key);
+    return null;
+  }
+  return entry.html;
+}
+function deleteSegment(key) {
+  getStore().delete(key);
+}
+function clearSegments() {
+  getStore().clear();
+}
+var CACHE_TAG = "hadars-c";
+
+// src/components/CacheSegment.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function CacheSegment({ cacheKey, ttl, children }) {
+  if (typeof window !== "undefined") {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children });
+  }
+  const cached = getSegment(cacheKey);
+  if (cached !== null) {
+    return import_react2.default.createElement(CACHE_TAG, {
+      "data-key": cacheKey,
+      "data-cache": "hit",
+      dangerouslySetInnerHTML: { __html: cached }
+    });
+  }
+  const props = {
+    "data-key": cacheKey,
+    "data-cache": "miss"
+  };
+  if (ttl != null)
+    props["data-ttl"] = ttl;
+  return import_react2.default.createElement(CACHE_TAG, props, children);
+}
+
 // src/index.tsx
 var HadarsContext = typeof window === "undefined" ? AppProviderSSR : AppProviderCSR;
 function loadModule(path) {
@@ -308,8 +360,11 @@ function loadModule(path) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CacheSegment,
   HadarsContext,
   HadarsHead,
+  clearSegments,
+  deleteSegment,
   initServerDataCache,
   loadModule,
   useServerData

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import * as React$1 from 'react';
 import React__default, { MetaHTMLAttributes, LinkHTMLAttributes, StyleHTMLAttributes, ScriptHTMLAttributes } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 
 type HadarsGetInitialProps<T extends {}> = (req: HadarsRequest) => Promise<T> | T;
 type HadarsGetClientProps<T extends {}> = (props: T) => Promise<T> | T;
@@ -181,6 +182,44 @@ declare const Head: React__default.FC<{
     status?: number;
 }>;
 
+interface CacheSegmentProps {
+    /**
+     * Unique cache key for this segment. Use a key that encodes all values
+     * the output depends on, e.g. `"product-" + product.id`.
+     */
+    cacheKey: string;
+    /**
+     * Time-to-live in milliseconds. Omit for entries that never expire.
+     */
+    ttl?: number;
+    children: React__default.ReactNode;
+}
+/**
+ * Caches the server-rendered HTML of its children across requests.
+ *
+ * **Server (SSR):**
+ * - Cache miss — children are rendered normally as part of the main
+ *   `renderToString` call, so React context propagates correctly. The output
+ *   is wrapped in a `<hadars-c>` marker that `processSegmentCache` uses to
+ *   extract and store the HTML. The marker is stripped before the response
+ *   is sent; the browser never sees it.
+ * - Cache hit — children are **not** rendered at all. The cached HTML is
+ *   injected directly, saving the entire subtree render cost.
+ *
+ * **Client:** renders children normally (no caching). Because the server
+ * strips the marker wrapper, the client output matches the server HTML and
+ * React hydration succeeds without warnings for deterministic components.
+ *
+ * **Note:** components that rely on request-specific data (cookies, auth,
+ * personalisation) must not be wrapped in `CacheSegment` unless the cache
+ * key encodes that data — otherwise a cached response for one user could be
+ * served to another.
+ */
+declare function CacheSegment({ cacheKey, ttl, children }: CacheSegmentProps): react_jsx_runtime.JSX.Element;
+
+declare function deleteSegment(key: string): void;
+declare function clearSegments(): void;
+
 declare const HadarsContext: React$1.FC<{
     children: React.ReactNode;
     context: AppContext;
@@ -205,4 +244,4 @@ declare const HadarsContext: React$1.FC<{
  */
 declare function loadModule<T = any>(path: string): Promise<T>;
 
-export { HadarsApp, HadarsContext, HadarsEntryModule, HadarsGetAfterRenderProps, HadarsGetClientProps, HadarsGetFinalProps, HadarsGetInitialProps, Head as HadarsHead, HadarsOptions, HadarsProps, HadarsRequest, initServerDataCache, loadModule, useServerData };
+export { CacheSegment, HadarsApp, HadarsContext, HadarsEntryModule, HadarsGetAfterRenderProps, HadarsGetClientProps, HadarsGetFinalProps, HadarsGetInitialProps, Head as HadarsHead, HadarsOptions, HadarsProps, HadarsRequest, clearSegments, deleteSegment, initServerDataCache, loadModule, useServerData };

package/dist/index.js

@@ -176,8 +176,7 @@ function useServerData(key, fn) {
           }
         );
         unsuspend.cache.set(cacheKey, { status: "pending", promise: suspensePromise });
-        unsuspend.hasPending = true;
-        return void 0;
+        throw suspensePromise;
       }
       throw thrown;
     }
@@ -196,12 +195,10 @@ function useServerData(key, fn) {
       }
     );
     unsuspend.cache.set(cacheKey, { status: "pending", promise });
-    unsuspend.hasPending = true;
-    return void 0;
+    throw promise;
   }
   if (existing.status === "pending") {
-    unsuspend.hasPending = true;
-    return void 0;
+    throw existing.promise;
   }
   if (existing.status === "rejected")
     throw existing.reason;
@@ -258,6 +255,58 @@ var Head = React.memo(({ children, status }) => {
   return null;
 });
 
+// src/components/CacheSegment.tsx
+import React2 from "react";
+
+// src/utils/segmentCache.ts
+function getStore() {
+  const g = globalThis;
+  if (!g.__hadarsSegmentStore) {
+    g.__hadarsSegmentStore = /* @__PURE__ */ new Map();
+  }
+  return g.__hadarsSegmentStore;
+}
+function getSegment(key) {
+  const entry = getStore().get(key);
+  if (!entry)
+    return null;
+  if (entry.expiresAt !== null && Date.now() >= entry.expiresAt) {
+    getStore().delete(key);
+    return null;
+  }
+  return entry.html;
+}
+function deleteSegment(key) {
+  getStore().delete(key);
+}
+function clearSegments() {
+  getStore().clear();
+}
+var CACHE_TAG = "hadars-c";
+
+// src/components/CacheSegment.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function CacheSegment({ cacheKey, ttl, children }) {
+  if (typeof window !== "undefined") {
+    return /* @__PURE__ */ jsx2(Fragment, { children });
+  }
+  const cached = getSegment(cacheKey);
+  if (cached !== null) {
+    return React2.createElement(CACHE_TAG, {
+      "data-key": cacheKey,
+      "data-cache": "hit",
+      dangerouslySetInnerHTML: { __html: cached }
+    });
+  }
+  const props = {
+    "data-key": cacheKey,
+    "data-cache": "miss"
+  };
+  if (ttl != null)
+    props["data-ttl"] = ttl;
+  return React2.createElement(CACHE_TAG, props, children);
+}
+
 // src/index.tsx
 var HadarsContext = typeof window === "undefined" ? AppProviderSSR : AppProviderCSR;
 function loadModule(path) {
@@ -267,8 +316,11 @@ function loadModule(path) {
   );
 }
 export {
+  CacheSegment,
   HadarsContext,
   Head as HadarsHead,
+  clearSegments,
+  deleteSegment,
   initServerDataCache,
   loadModule,
   useServerData

package/dist/jsx-runtime-97ca74a5.d.ts

@@ -0,0 +1,18 @@
+declare const SLIM_ELEMENT: unique symbol;
+declare const FRAGMENT_TYPE: unique symbol;
+declare const SUSPENSE_TYPE: unique symbol;
+type ComponentFunction = (props: any) => SlimNode;
+type SlimElement = {
+    $$typeof: typeof SLIM_ELEMENT;
+    type: string | ComponentFunction | symbol;
+    props: Record<string, any>;
+    key: string | number | null;
+};
+type SlimNode = SlimElement | string | number | boolean | null | undefined | SlimNode[];
+
+declare const Fragment: symbol;
+declare function jsx(type: string | ComponentFunction | symbol, props: Record<string, any>, key?: string | number | null): SlimElement;
+
+declare function createElement(type: string | ComponentFunction | symbol, props?: Record<string, any> | null, ...children: SlimNode[]): SlimElement;
+
+export { ComponentFunction as C, Fragment as F, SlimNode as S, SlimElement as a, SLIM_ELEMENT as b, createElement as c, FRAGMENT_TYPE as d, SUSPENSE_TYPE as e, jsx as j };