@vtex/faststore 0.0.1

package/dist/sdk/context/storefront-context.js

@@ -0,0 +1,29 @@
+"use client";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/sdk/context/storefront-context.tsx
+/**
+* Private, so the only read is `useStorefrontContext` — which can tell an unprovided tree from a
+* provided one instead of silently handing out a default locale.
+*/
+const Context = createContext(null);
+/** Publishes the context the generated app handed `StorefrontProvider` to the Client tree. */
+function StorefrontContextProvider({ context, children }) {
+	return /* @__PURE__ */ jsx(Context.Provider, {
+		value: context,
+		children
+	});
+}
+/**
+* The active storefront context: locale, currency, sales channel, country, timezone, and text
+* direction. Throws outside a `StorefrontProvider` that received a `context`.
+*/
+function useStorefrontContext() {
+	const context = useContext(Context);
+	if (!context) throw new Error("useStorefrontContext: no storefront context in this tree. Render under a `StorefrontProvider` that receives a `context` prop — the generated app passes the `storefrontContext` constant from `src/utils/storefront-context.ts`.");
+	return context;
+}
+//#endregion
+export { StorefrontContextProvider, useStorefrontContext };
+
+//# sourceMappingURL=storefront-context.js.map

package/dist/sdk/context/storefront-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storefront-context.js","names":[],"sources":["../../../src/sdk/context/storefront-context.tsx"],"sourcesContent":["'use client';\n\nimport type { StorefrontContext } from '@vtex/fs-core';\nimport { createContext, type ReactNode, useContext } from 'react';\n\nexport type StorefrontContextProviderProps = Readonly<{\n  /** `null` when the app declared no context, which makes every read throw rather than default. */\n  context: StorefrontContext | null;\n  children: ReactNode;\n}>;\n\n/**\n * Private, so the only read is `useStorefrontContext` — which can tell an unprovided tree from a\n * provided one instead of silently handing out a default locale.\n */\nconst Context = createContext<StorefrontContext | null>(null);\n\n/** Publishes the context the generated app handed `StorefrontProvider` to the Client tree. */\nexport function StorefrontContextProvider({ context, children }: StorefrontContextProviderProps) {\n  return <Context.Provider value={context}>{children}</Context.Provider>;\n}\n\n/**\n * The active storefront context: locale, currency, sales channel, country, timezone, and text\n * direction. Throws outside a `StorefrontProvider` that received a `context`.\n */\nexport function useStorefrontContext(): StorefrontContext {\n  const context = useContext(Context);\n  if (!context) {\n    throw new Error(\n      'useStorefrontContext: no storefront context in this tree. Render under a ' +\n        '`StorefrontProvider` that receives a `context` prop — the generated app passes the ' +\n        '`storefrontContext` constant from `src/utils/storefront-context.ts`.',\n    );\n  }\n  return context;\n}\n"],"mappings":";;;;;;;;AAeA,MAAM,UAAU,cAAwC,IAAI;;AAG5D,SAAgB,0BAA0B,EAAE,SAAS,YAA4C;CAC/F,OAAO,oBAAC,QAAQ,UAAT;EAAkB,OAAO;EAAU;CAA2B,CAAA;AACvE;;;;;AAMA,SAAgB,uBAA0C;CACxD,MAAM,UAAU,WAAW,OAAO;CAClC,IAAI,CAAC,SACH,MAAM,IAAI,MACR,kOAGF;CAEF,OAAO;AACT"}

package/dist/sdk/data/data-override-context.d.ts

@@ -0,0 +1,12 @@
+//#region src/sdk/data/data-override-context.d.ts
+/**
+ * Context used by HotDataProvider, ReactiveDataProvider, and ReactiveListItemDataProvider to inject
+ * resolved `$data` into descendant data-root components without cloneElement — which breaks in
+ * React 19 RSC because children cross the flight boundary as lazy elements that isValidElement /
+ * cloneElement cannot handle. This is also why a `reactive-list-item` element is emitted with no
+ * `$data` prop: the per-line slice arrives here through the iteration context, never as a prop.
+ */
+export declare const DataOverrideContext: import("react").Context<unknown>;
+export declare function useDataOverride<T>($data: T): T;
+//#endregion
+//# sourceMappingURL=data-override-context.d.ts.map

package/dist/sdk/data/data-override-context.js

@@ -0,0 +1,19 @@
+"use client";
+import { createContext, useContext } from "react";
+//#region src/sdk/data/data-override-context.ts
+/**
+* Context used by HotDataProvider, ReactiveDataProvider, and ReactiveListItemDataProvider to inject
+* resolved `$data` into descendant data-root components without cloneElement — which breaks in
+* React 19 RSC because children cross the flight boundary as lazy elements that isValidElement /
+* cloneElement cannot handle. This is also why a `reactive-list-item` element is emitted with no
+* `$data` prop: the per-line slice arrives here through the iteration context, never as a prop.
+*/
+const DataOverrideContext = createContext(void 0);
+function useDataOverride($data) {
+	const override = useContext(DataOverrideContext);
+	return override === void 0 ? $data : override;
+}
+//#endregion
+export { DataOverrideContext, useDataOverride };
+
+//# sourceMappingURL=data-override-context.js.map

package/dist/sdk/data/data-override-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-override-context.js","names":[],"sources":["../../../src/sdk/data/data-override-context.ts"],"sourcesContent":["'use client';\n\nimport { createContext, useContext } from 'react';\n\n/**\n * Context used by HotDataProvider, ReactiveDataProvider, and ReactiveListItemDataProvider to inject\n * resolved `$data` into descendant data-root components without cloneElement — which breaks in\n * React 19 RSC because children cross the flight boundary as lazy elements that isValidElement /\n * cloneElement cannot handle. This is also why a `reactive-list-item` element is emitted with no\n * `$data` prop: the per-line slice arrives here through the iteration context, never as a prop.\n */\nexport const DataOverrideContext = createContext<unknown>(undefined);\n\nexport function useDataOverride<T>($data: T): T {\n  const override = useContext(DataOverrideContext);\n  return (override === undefined ? $data : override) as T;\n}\n"],"mappings":";;;;;;;;;;AAWA,MAAa,sBAAsB,cAAuB,KAAA,CAAS;AAEnE,SAAgB,gBAAmB,OAAa;CAC9C,MAAM,WAAW,WAAW,mBAAmB;CAC/C,OAAQ,aAAa,KAAA,IAAY,QAAQ;AAC3C"}

package/dist/sdk/data/entity-subscriber.js

@@ -0,0 +1,28 @@
+"use client";
+import { DataOverrideContext } from "./data-override-context.js";
+import { useReactiveEntity } from "./use-reactive-entity.js";
+import { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/sdk/data/entity-subscriber.tsx
+/**
+* Per-entity subscriber used internally by `MultipleReactiveDataProvider` to compose several
+* entities' cache slices into one keyed `$data` object for a single component. Resolves its own
+* slice exactly like `ReactiveDataProvider` (see `useReactiveEntity`), then merges it under
+* `rootField` into the outer `DataOverrideContext` value.
+*/
+function EntitySubscriber({ entityFragment, fragmentName, rootField, fallbackData, reset, children }) {
+	const outer = useContext(DataOverrideContext);
+	const resolved = useReactiveEntity(entityFragment, fragmentName, rootField, fallbackData);
+	const value = reset ? { [rootField]: resolved } : {
+		...outer && typeof outer === "object" ? outer : {},
+		[rootField]: resolved
+	};
+	return /* @__PURE__ */ jsx(DataOverrideContext, {
+		value,
+		children
+	});
+}
+//#endregion
+export { EntitySubscriber };
+
+//# sourceMappingURL=entity-subscriber.js.map

package/dist/sdk/data/entity-subscriber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-subscriber.js","names":[],"sources":["../../../src/sdk/data/entity-subscriber.tsx"],"sourcesContent":["'use client';\n\nimport type { DocumentNode } from '@apollo/client';\nimport type { ReactNode } from 'react';\nimport { useContext } from 'react';\nimport { DataOverrideContext } from './data-override-context.js';\nimport { useReactiveEntity } from './use-reactive-entity.js';\n\nexport type EntitySubscriberProps = Readonly<{\n  /** Derived `fragment <X>_<EntityType> on <EntityType>` document emitted by the compiler. */\n  entityFragment: DocumentNode;\n  /** Name of the derived fragment, passed to `useFragment`. */\n  fragmentName: string;\n  /** Top-level field of the page query (e.g. 'cart') used to extract the entity ref, and the key\n   * under which the resolved slice is merged into the composed `$data` object. */\n  rootField: string;\n  /** Server-rendered fragment payload; used until the cache resolves a complete entity slice. */\n  fallbackData: unknown;\n  /**\n   * When `true`, RESETS the context to `{ [rootField]: resolved }`, discarding any outer\n   * `DataOverrideContext` value — this is the outermost subscriber of a component's nested stack,\n   * and prevents a parent component's `$data` from leaking into this component's descendants. When\n   * `false`, merges this subscriber's slice into the SAME-stack outer value instead.\n   */\n  reset: boolean;\n  children: ReactNode;\n}>;\n\n/**\n * Per-entity subscriber used internally by `MultipleReactiveDataProvider` to compose several\n * entities' cache slices into one keyed `$data` object for a single component. Resolves its own\n * slice exactly like `ReactiveDataProvider` (see `useReactiveEntity`), then merges it under\n * `rootField` into the outer `DataOverrideContext` value.\n */\nexport function EntitySubscriber({\n  entityFragment,\n  fragmentName,\n  rootField,\n  fallbackData,\n  reset,\n  children,\n}: EntitySubscriberProps): ReactNode {\n  const outer = useContext(DataOverrideContext);\n  const resolved = useReactiveEntity(entityFragment, fragmentName, rootField, fallbackData);\n\n  const value = reset\n    ? { [rootField]: resolved }\n    : { ...(outer && typeof outer === 'object' ? outer : {}), [rootField]: resolved };\n\n  return <DataOverrideContext value={value}>{children}</DataOverrideContext>;\n}\n"],"mappings":";;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,EAC/B,gBACA,cACA,WACA,cACA,OACA,YACmC;CACnC,MAAM,QAAQ,WAAW,mBAAmB;CAC5C,MAAM,WAAW,kBAAkB,gBAAgB,cAAc,WAAW,YAAY;CAExF,MAAM,QAAQ,QACV,GAAG,YAAY,SAAS,IACxB;EAAE,GAAI,SAAS,OAAO,UAAU,WAAW,QAAQ,CAAC;GAAK,YAAY;CAAS;CAElF,OAAO,oBAAC,qBAAD;EAA4B;EAAQ;CAA8B,CAAA;AAC3E"}

package/dist/sdk/data/hot-data-provider.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from "react";
+import { OperationVariables, TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/data/hot-data-provider.d.ts
+export type HotDataProviderProps<TData, TVariables extends OperationVariables> = Readonly<{
+  query: TypedDocumentNode<TData, TVariables>;
+  variables: TVariables;
+  /** Top-level field of the fragment to forward as `$data`. */
+  field: string;
+  /**
+   * Server-rendered value from the composed PAGE_QUERY result. It paints the first frame — `useQuery`
+   * issues no request during SSR and the client cache is empty at hydration — and stays on screen on
+   * error or a null payload.
+   */
+  fallbackData: unknown;
+  children: ReactNode;
+}>;
+export declare function HotDataProvider<TData, TVariables extends OperationVariables>({ query, variables, field, fallbackData, children }: HotDataProviderProps<TData, TVariables>): ReactNode;
+//#endregion
+//# sourceMappingURL=hot-data-provider.d.ts.map

package/dist/sdk/data/hot-data-provider.js

@@ -0,0 +1,33 @@
+"use client";
+import { DataOverrideContext } from "./data-override-context.js";
+import { useQuery } from "@apollo/client/react";
+import { useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/sdk/data/hot-data-provider.tsx
+function HotDataProvider({ query, variables, field, fallbackData, children }) {
+	const { data, error } = useQuery(query, {
+		variables,
+		errorPolicy: "all",
+		fetchPolicy: "cache-and-network"
+	});
+	const errorLoggedRef = useRef(false);
+	useEffect(() => {
+		if (error && !errorLoggedRef.current) {
+			errorLoggedRef.current = true;
+			console.error("[HotDataProvider] lazy fetch failed; falling back to composed page data.", error);
+		}
+	}, [error]);
+	let resolved = fallbackData;
+	if (!error && data != null) {
+		const fieldValue = data[field];
+		if (fieldValue != null) resolved = fieldValue;
+	}
+	return /* @__PURE__ */ jsx(DataOverrideContext, {
+		value: resolved,
+		children
+	});
+}
+//#endregion
+export { HotDataProvider };
+
+//# sourceMappingURL=hot-data-provider.js.map

package/dist/sdk/data/hot-data-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hot-data-provider.js","names":[],"sources":["../../../src/sdk/data/hot-data-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { OperationVariables, TypedDocumentNode } from '@apollo/client';\nimport { useQuery } from '@apollo/client/react';\nimport type { ReactNode } from 'react';\nimport { useEffect, useRef } from 'react';\nimport { DataOverrideContext } from './data-override-context.js';\n\nexport type HotDataProviderProps<TData, TVariables extends OperationVariables> = Readonly<{\n  query: TypedDocumentNode<TData, TVariables>;\n  variables: TVariables;\n  /** Top-level field of the fragment to forward as `$data`. */\n  field: string;\n  /**\n   * Server-rendered value from the composed PAGE_QUERY result. It paints the first frame — `useQuery`\n   * issues no request during SSR and the client cache is empty at hydration — and stays on screen on\n   * error or a null payload.\n   */\n  fallbackData: unknown;\n  children: ReactNode;\n}>;\n\nexport function HotDataProvider<TData, TVariables extends OperationVariables>({\n  query,\n  variables,\n  field,\n  fallbackData,\n  children,\n}: HotDataProviderProps<TData, TVariables>): ReactNode {\n  // Non-suspending, so the element never becomes a boundary and the route stays one contiguous\n  // response. `cache-and-network` rather than `cache-first`: on a repeat client-side navigation the\n  // cache is warm and the whole point of a hot field is that it refreshes anyway.\n  const { data, error } = useQuery(query, {\n    variables,\n    errorPolicy: 'all',\n    fetchPolicy: 'cache-and-network',\n  });\n\n  const errorLoggedRef = useRef(false);\n  useEffect(() => {\n    if (error && !errorLoggedRef.current) {\n      errorLoggedRef.current = true;\n      console.error('[HotDataProvider] lazy fetch failed; falling back to composed page data.', error);\n    }\n  }, [error]);\n\n  let resolved: unknown = fallbackData;\n  if (!error && data != null) {\n    const fieldValue = (data as Record<string, unknown>)[field];\n    if (fieldValue != null) {\n      resolved = fieldValue;\n    }\n  }\n\n  return <DataOverrideContext value={resolved}>{children}</DataOverrideContext>;\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,gBAA8D,EAC5E,OACA,WACA,OACA,cACA,YACqD;CAIrD,MAAM,EAAE,MAAM,UAAU,SAAS,OAAO;EACtC;EACA,aAAa;EACb,aAAa;CACf,CAAC;CAED,MAAM,iBAAiB,OAAO,KAAK;CACnC,gBAAgB;EACd,IAAI,SAAS,CAAC,eAAe,SAAS;GACpC,eAAe,UAAU;GACzB,QAAQ,MAAM,4EAA4E,KAAK;EACjG;CACF,GAAG,CAAC,KAAK,CAAC;CAEV,IAAI,WAAoB;CACxB,IAAI,CAAC,SAAS,QAAQ,MAAM;EAC1B,MAAM,aAAc,KAAiC;EACrD,IAAI,cAAc,MAChB,WAAW;CAEf;CAEA,OAAO,oBAAC,qBAAD;EAAqB,OAAO;EAAW;CAA8B,CAAA;AAC9E"}

package/dist/sdk/data/index.d.ts

@@ -0,0 +1,8 @@
+import { DataOverrideContext, useDataOverride } from "./data-override-context.js";
+import { HotDataProvider, HotDataProviderProps } from "./hot-data-provider.js";
+import { ListItemRef, ListItemRefContext, useListItemRef } from "./list-item-ref-context.js";
+import { MultipleReactiveDataProvider, MultipleReactiveDataProviderEntity, MultipleReactiveDataProviderProps } from "./multiple-reactive-data-provider.js";
+import { ClientVariablesMap, PageReactiveDataRoot, PageReactiveDataRootProps, ReactiveRootContext, ReactiveRootContextValue } from "./page-reactive-data-root.js";
+import { ReactiveDataProvider, ReactiveDataProviderProps } from "./reactive-data-provider.js";
+import { ReactiveListItemDataProvider, ReactiveListItemDataProviderProps } from "./reactive-list-item-data-provider.js";
+export { type ClientVariablesMap, DataOverrideContext, HotDataProvider, type HotDataProviderProps, type ListItemRef, ListItemRefContext, MultipleReactiveDataProvider, type MultipleReactiveDataProviderEntity, type MultipleReactiveDataProviderProps, PageReactiveDataRoot, type PageReactiveDataRootProps, ReactiveDataProvider, type ReactiveDataProviderProps, ReactiveListItemDataProvider, type ReactiveListItemDataProviderProps, ReactiveRootContext, type ReactiveRootContextValue, useDataOverride, useListItemRef };

package/dist/sdk/data/index.js

@@ -0,0 +1,8 @@
+import { DataOverrideContext, useDataOverride } from "./data-override-context.js";
+import { HotDataProvider } from "./hot-data-provider.js";
+import { ListItemRefContext, useListItemRef } from "./list-item-ref-context.js";
+import { PageReactiveDataRoot, ReactiveRootContext } from "./page-reactive-data-root.js";
+import { MultipleReactiveDataProvider } from "./multiple-reactive-data-provider.js";
+import { ReactiveDataProvider } from "./reactive-data-provider.js";
+import { ReactiveListItemDataProvider } from "./reactive-list-item-data-provider.js";
+export { DataOverrideContext, HotDataProvider, ListItemRefContext, MultipleReactiveDataProvider, PageReactiveDataRoot, ReactiveDataProvider, ReactiveListItemDataProvider, ReactiveRootContext, useDataOverride, useListItemRef };

package/dist/sdk/data/list-item-ref-context.d.ts

@@ -0,0 +1,20 @@
+//#region src/sdk/data/list-item-ref-context.d.ts
+/**
+ * Per-iterated-line entity ref published by an iterator (e.g. `CartList`) so a
+ * `<ReactiveListItemDataProvider>` rendered inside the iteration can subscribe to that one line's
+ * normalized cache entity. It carries the addressing tuple (`__typename` + `id`) and the
+ * server-rendered slice used as fallback until the cache slice is complete.
+ *
+ * This is the generic, SDK-owned seam the per-item provider reads: the iterator depends on the SDK
+ * (not the reverse), so a cart-specific context never has to be imported into `sdk/data`.
+ */
+export type ListItemRef = {
+  __typename: string;
+  id: string | number;
+  /** Server-rendered slice for this line; the provider falls back to it until the cache is complete. */
+  fallbackData: unknown;
+};
+export declare const ListItemRefContext: import("react").Context<ListItemRef | undefined>;
+export declare function useListItemRef(): ListItemRef | undefined;
+//#endregion
+//# sourceMappingURL=list-item-ref-context.d.ts.map

package/dist/sdk/data/list-item-ref-context.js

@@ -0,0 +1,11 @@
+"use client";
+import { createContext, useContext } from "react";
+//#region src/sdk/data/list-item-ref-context.tsx
+const ListItemRefContext = createContext(void 0);
+function useListItemRef() {
+	return useContext(ListItemRefContext);
+}
+//#endregion
+export { ListItemRefContext, useListItemRef };
+
+//# sourceMappingURL=list-item-ref-context.js.map

package/dist/sdk/data/list-item-ref-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item-ref-context.js","names":[],"sources":["../../../src/sdk/data/list-item-ref-context.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, useContext } from 'react';\n\n/**\n * Per-iterated-line entity ref published by an iterator (e.g. `CartList`) so a\n * `<ReactiveListItemDataProvider>` rendered inside the iteration can subscribe to that one line's\n * normalized cache entity. It carries the addressing tuple (`__typename` + `id`) and the\n * server-rendered slice used as fallback until the cache slice is complete.\n *\n * This is the generic, SDK-owned seam the per-item provider reads: the iterator depends on the SDK\n * (not the reverse), so a cart-specific context never has to be imported into `sdk/data`.\n */\nexport type ListItemRef = {\n  __typename: string;\n  id: string | number;\n  /** Server-rendered slice for this line; the provider falls back to it until the cache is complete. */\n  fallbackData: unknown;\n};\n\nexport const ListItemRefContext = createContext<ListItemRef | undefined>(undefined);\n\nexport function useListItemRef(): ListItemRef | undefined {\n  return useContext(ListItemRefContext);\n}\n"],"mappings":";;;AAoBA,MAAa,qBAAqB,cAAuC,KAAA,CAAS;AAElF,SAAgB,iBAA0C;CACxD,OAAO,WAAW,kBAAkB;AACtC"}

package/dist/sdk/data/multiple-reactive-data-provider.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from "react";
+import { DocumentNode } from "@apollo/client";
+//#region src/sdk/data/multiple-reactive-data-provider.d.ts
+export type MultipleReactiveDataProviderEntity = Readonly<{
+  /** Derived `fragment <X>_<EntityType> on <EntityType>` document emitted by the compiler. */
+  entityFragment: DocumentNode;
+  /** Name of the derived fragment, passed to `useFragment`. */
+  fragmentName: string;
+  /** Top-level field of the page query (e.g. 'cart') used to extract the entity ref, and the key
+   * under which the resolved slice is merged into the composed `$data` object. */
+  rootField: string;
+  /** Server-rendered fragment payload; used until the cache resolves a complete entity slice. */
+  fallbackData: unknown;
+}>;
+export type MultipleReactiveDataProviderProps = Readonly<{
+  /**
+   * Entities consumed by a single component, each contributing a keyed slice to the composed
+   * `$data` object. `entities[0]` is treated as the outermost subscriber — it resets the
+   * `DataOverrideContext` so an ancestor component's `$data` never leaks in — and each subsequent
+   * entity nests inside it, merging its slice under its own `rootField`.
+   */
+  entities: readonly MultipleReactiveDataProviderEntity[];
+  children: ReactNode;
+}>;
+/**
+ * Composes multiple entity subscriptions into a single keyed `$data` object for one component
+ * (AD-4 / AD-D2 multi-entity case), by nesting an `EntitySubscriber` per entity via `reduceRight`.
+ * Calls no hooks itself — all cache reads happen in the nested `EntitySubscriber`s.
+ */
+export declare function MultipleReactiveDataProvider({ entities, children }: MultipleReactiveDataProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=multiple-reactive-data-provider.d.ts.map

package/dist/sdk/data/multiple-reactive-data-provider.js

@@ -0,0 +1,20 @@
+"use client";
+import { EntitySubscriber } from "./entity-subscriber.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/sdk/data/multiple-reactive-data-provider.tsx
+/**
+* Composes multiple entity subscriptions into a single keyed `$data` object for one component
+* (AD-4 / AD-D2 multi-entity case), by nesting an `EntitySubscriber` per entity via `reduceRight`.
+* Calls no hooks itself — all cache reads happen in the nested `EntitySubscriber`s.
+*/
+function MultipleReactiveDataProvider({ entities, children }) {
+	return entities.reduceRight((inner, entity, index) => /* @__PURE__ */ jsx(EntitySubscriber, {
+		...entity,
+		reset: index === 0,
+		children: inner
+	}, entity.rootField), children);
+}
+//#endregion
+export { MultipleReactiveDataProvider };
+
+//# sourceMappingURL=multiple-reactive-data-provider.js.map

package/dist/sdk/data/multiple-reactive-data-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiple-reactive-data-provider.js","names":[],"sources":["../../../src/sdk/data/multiple-reactive-data-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { DocumentNode } from '@apollo/client';\nimport type { ReactNode } from 'react';\nimport { EntitySubscriber } from './entity-subscriber.js';\n\nexport type MultipleReactiveDataProviderEntity = Readonly<{\n  /** Derived `fragment <X>_<EntityType> on <EntityType>` document emitted by the compiler. */\n  entityFragment: DocumentNode;\n  /** Name of the derived fragment, passed to `useFragment`. */\n  fragmentName: string;\n  /** Top-level field of the page query (e.g. 'cart') used to extract the entity ref, and the key\n   * under which the resolved slice is merged into the composed `$data` object. */\n  rootField: string;\n  /** Server-rendered fragment payload; used until the cache resolves a complete entity slice. */\n  fallbackData: unknown;\n}>;\n\nexport type MultipleReactiveDataProviderProps = Readonly<{\n  /**\n   * Entities consumed by a single component, each contributing a keyed slice to the composed\n   * `$data` object. `entities[0]` is treated as the outermost subscriber — it resets the\n   * `DataOverrideContext` so an ancestor component's `$data` never leaks in — and each subsequent\n   * entity nests inside it, merging its slice under its own `rootField`.\n   */\n  entities: readonly MultipleReactiveDataProviderEntity[];\n  children: ReactNode;\n}>;\n\n/**\n * Composes multiple entity subscriptions into a single keyed `$data` object for one component\n * (AD-4 / AD-D2 multi-entity case), by nesting an `EntitySubscriber` per entity via `reduceRight`.\n * Calls no hooks itself — all cache reads happen in the nested `EntitySubscriber`s.\n */\nexport function MultipleReactiveDataProvider({ entities, children }: MultipleReactiveDataProviderProps): ReactNode {\n  return entities.reduceRight<ReactNode>(\n    (inner, entity, index) => (\n      <EntitySubscriber key={entity.rootField} {...entity} reset={index === 0}>\n        {inner}\n      </EntitySubscriber>\n    ),\n    children,\n  );\n}\n"],"mappings":";;;;;;;;;AAkCA,SAAgB,6BAA6B,EAAE,UAAU,YAA0D;CACjH,OAAO,SAAS,aACb,OAAO,QAAQ,UACd,oBAAC,kBAAD;EAAyC,GAAI;EAAQ,OAAO,UAAU;EACnE,UAAA;CACe,GAFK,OAAO,SAEZ,GAEpB,QACF;AACF"}

package/dist/sdk/data/page-reactive-data-root.d.ts

@@ -0,0 +1,53 @@
+import { ReactNode } from "react";
+import { ErrorLike, OperationVariables, ReactiveVar, TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/data/page-reactive-data-root.d.ts
+/**
+ * Compile-time-stable map keyed by the operation's variable names. Each value is either an Apollo
+ * reactive variable (`makeVar`) or the string name of one registered in REACTIVE_VAR_REGISTRY —
+ * Server Components must pass strings because functions cannot cross the RSC boundary. Vars that
+ * have not yet resolved should hold `null`; the runtime treats both `null` and `undefined` as
+ * "not yet ready" and keeps `useQuery` skipped.
+ */
+export type ClientVariablesMap<TVars> = Partial<{ [K in keyof TVars]: ReactiveVar<TVars[K] | null> | string; }>;
+export type PageReactiveDataRootProps<TData, TVars extends OperationVariables> = Readonly<{
+  /** The composed PAGE_QUERY operation document. */
+  query: TypedDocumentNode<TData, TVars>;
+  /** Variables the server used when calling fetchPageData. Only used to seed the client cache. */
+  serverVariables?: TVars;
+  /** Server-rendered PAGE_QUERY result. When present and shape-matched, seeded into the cache once. */
+  initialData?: TData | null;
+  /** Reactive vars whose current values are merged into operation variables at render time. */
+  clientVariables?: ClientVariablesMap<TVars>;
+  children: ReactNode;
+}>;
+export type ReactiveRootContextValue<TData = unknown> = Readonly<{
+  /** Current root query data exposed to descendant `ReactiveDataProvider`s. */
+  rootQueryData: TData | undefined;
+  /** Whether the underlying useQuery is currently in flight. */
+  loading: boolean;
+  /** False when at least one required variable has not been provided yet. */
+  hasAllRequiredVariables: boolean;
+  /**
+   * Error from the underlying useQuery. With non-null root fields (e.g. `cart: Cart!`), a failed
+   * fetch nulls the whole operation's `data` — descendants need this to tell "fetch failed" apart
+   * from "entity is legitimately absent" (specs/cart-context-client-migrate.md US-5).
+   */
+  error: ErrorLike | undefined;
+}>;
+export declare const ReactiveRootContext: import("react").Context<Readonly<{
+  /** Current root query data exposed to descendant `ReactiveDataProvider`s. */
+  rootQueryData: unknown;
+  /** Whether the underlying useQuery is currently in flight. */
+  loading: boolean;
+  /** False when at least one required variable has not been provided yet. */
+  hasAllRequiredVariables: boolean;
+  /**
+   * Error from the underlying useQuery. With non-null root fields (e.g. `cart: Cart!`), a failed
+   * fetch nulls the whole operation's `data` — descendants need this to tell "fetch failed" apart
+   * from "entity is legitimately absent" (specs/cart-context-client-migrate.md US-5).
+   */
+  error: ErrorLike | undefined;
+}>>;
+export declare function PageReactiveDataRoot<TData = unknown, TVars extends OperationVariables = OperationVariables>(props: PageReactiveDataRootProps<TData, TVars>): ReactNode;
+//#endregion
+//# sourceMappingURL=page-reactive-data-root.d.ts.map

package/dist/sdk/data/page-reactive-data-root.js

@@ -0,0 +1,153 @@
+"use client";
+import { useApolloClient, useQuery } from "@apollo/client/react";
+import { createContext, useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "react";
+import { jsx } from "react/jsx-runtime";
+import { Kind } from "graphql";
+//#region src/sdk/data/page-reactive-data-root.tsx
+const REACTIVE_VAR_REGISTRY = {};
+function resolveReactiveVar(value) {
+	if (typeof value === "function") return value;
+	const resolved = REACTIVE_VAR_REGISTRY[value];
+	if (!resolved) throw new Error(`PageReactiveDataRoot: clientVariables entry "${value}" is not registered. Add it to REACTIVE_VAR_REGISTRY in page-reactive-data-root.tsx.`);
+	return resolved;
+}
+const ReactiveRootContext = createContext({
+	rootQueryData: void 0,
+	loading: false,
+	hasAllRequiredVariables: false,
+	error: void 0
+});
+function getOperationDefinition(query) {
+	for (const definition of query.definitions) if (definition.kind === Kind.OPERATION_DEFINITION) return definition;
+}
+function getRequiredVariableNames(query) {
+	const op = getOperationDefinition(query);
+	if (!op?.variableDefinitions) return [];
+	const required = [];
+	for (const def of op.variableDefinitions) if (def.type.kind === Kind.NON_NULL_TYPE && def.defaultValue === void 0) required.push(def.variable.name.value);
+	return required;
+}
+function getTopLevelFieldNames(query) {
+	const op = getOperationDefinition(query);
+	const names = /* @__PURE__ */ new Set();
+	if (!op) return names;
+	for (const sel of op.selectionSet.selections) if (sel.kind === Kind.FIELD) names.add((sel.alias ?? sel.name).value);
+	return names;
+}
+function shapeMatches(query, data) {
+	if (data == null || typeof data !== "object") return false;
+	const expected = getTopLevelFieldNames(query);
+	if (expected.size === 0) return false;
+	const actual = data;
+	for (const key of expected) if (key in actual) return true;
+	return false;
+}
+/**
+* Reads the current values of every reactive var in `clientVariables` into a plain object via a
+* single `useSyncExternalStore` call (no hooks-in-loop). Apollo's `ReactiveVar.onNextChange` fires
+* once per registration, so the subscriber re-attaches after each notification to stay listening.
+*/
+function useClientVariableValues(clientVariables) {
+	const varsRef = useRef(clientVariables);
+	varsRef.current = clientVariables;
+	const subscribe = useCallback((notify) => {
+		const cv = varsRef.current;
+		if (!cv) return () => {};
+		const activeUnsubs = [];
+		let cancelled = false;
+		const attach = (rv) => {
+			if (cancelled) return;
+			const unsub = rv.onNextChange(() => {
+				notify();
+				attach(rv);
+			});
+			activeUnsubs.push(unsub);
+		};
+		for (const rv of Object.values(cv)) {
+			if (rv === void 0 || rv === null) continue;
+			const resolved = resolveReactiveVar(rv);
+			if (resolved) attach(resolved);
+		}
+		return () => {
+			cancelled = true;
+			for (const u of activeUnsubs) u();
+		};
+	}, []);
+	const lastSnapshotRef = useRef(null);
+	const getSnapshot = () => {
+		const cv = varsRef.current;
+		const snap = {};
+		if (cv) for (const [key, reactiveVar] of Object.entries(cv)) {
+			if (reactiveVar === void 0 || reactiveVar === null) continue;
+			const resolved = resolveReactiveVar(reactiveVar);
+			if (!resolved) continue;
+			const value = resolved();
+			if (value !== null && value !== void 0) snap[key] = value;
+		}
+		const json = JSON.stringify(snap);
+		if (lastSnapshotRef.current && lastSnapshotRef.current.json === json) return lastSnapshotRef.current.json;
+		lastSnapshotRef.current = {
+			json,
+			value: snap
+		};
+		return json;
+	};
+	useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+	return lastSnapshotRef.current?.value ?? {};
+}
+function PageReactiveDataRoot(props) {
+	const { query, serverVariables, initialData, clientVariables, children } = props;
+	const client = useApolloClient();
+	const seededRef = useRef(false);
+	const clientValues = useClientVariableValues(clientVariables);
+	const mergedVariables = {
+		...serverVariables ?? {},
+		...clientValues
+	};
+	const requiredNames = getRequiredVariableNames(query);
+	const mergedRecord = mergedVariables;
+	const hasAllRequiredVariables = requiredNames.every((name) => {
+		const v = mergedRecord[name];
+		return v !== null && v !== void 0;
+	});
+	useEffect(() => {
+		if (seededRef.current) return;
+		if (!serverVariables || initialData == null) return;
+		if (!shapeMatches(query, initialData)) return;
+		client.cache.writeQuery({
+			query,
+			variables: serverVariables,
+			data: initialData
+		});
+		seededRef.current = true;
+	}, [
+		client,
+		query,
+		serverVariables,
+		initialData
+	]);
+	const { data, loading, error } = useQuery(query, {
+		variables: mergedVariables,
+		fetchPolicy: "cache-first",
+		skip: !hasAllRequiredVariables
+	});
+	const contextValue = useMemo(() => ({
+		rootQueryData: data ?? void 0,
+		loading,
+		hasAllRequiredVariables,
+		error
+	}), [
+		data,
+		loading,
+		hasAllRequiredVariables,
+		error
+	]);
+	return /* @__PURE__ */ jsx(ReactiveRootContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+//#endregion
+export { PageReactiveDataRoot, ReactiveRootContext };
+
+//# sourceMappingURL=page-reactive-data-root.js.map

package/dist/sdk/data/page-reactive-data-root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-reactive-data-root.js","names":[],"sources":["../../../src/sdk/data/page-reactive-data-root.tsx"],"sourcesContent":["'use client';\n\nimport type { ErrorLike, OperationVariables, ReactiveVar, TypedDocumentNode } from '@apollo/client';\nimport { useApolloClient, useQuery } from '@apollo/client/react';\nimport { type DocumentNode, Kind, type OperationDefinitionNode } from 'graphql';\nimport { createContext, type ReactNode, useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';\n\n// Reactive vars resolvable by name from a Server Component. Functions cannot cross the\n// Server→Client boundary in RSC, so the compiler emits string keys and this component resolves\n// them at runtime. New reactive vars must be registered here to be addressable from generated\n// pages. Currently empty: cart context travels on the transport, so no cart entry is needed\n// (specs/cart-context-client-migrate.md).\nconst REACTIVE_VAR_REGISTRY: Record<string, ReactiveVar<unknown>> = {};\n\n/**\n * Compile-time-stable map keyed by the operation's variable names. Each value is either an Apollo\n * reactive variable (`makeVar`) or the string name of one registered in REACTIVE_VAR_REGISTRY —\n * Server Components must pass strings because functions cannot cross the RSC boundary. Vars that\n * have not yet resolved should hold `null`; the runtime treats both `null` and `undefined` as\n * \"not yet ready\" and keeps `useQuery` skipped.\n */\nexport type ClientVariablesMap<TVars> = Partial<{\n  [K in keyof TVars]: ReactiveVar<TVars[K] | null> | string;\n}>;\n\nfunction resolveReactiveVar(value: ReactiveVar<unknown> | string): ReactiveVar<unknown> | undefined {\n  if (typeof value === 'function') return value;\n  const resolved = REACTIVE_VAR_REGISTRY[value];\n  if (!resolved) {\n    throw new Error(\n      `PageReactiveDataRoot: clientVariables entry \"${value}\" is not registered. Add it to REACTIVE_VAR_REGISTRY in page-reactive-data-root.tsx.`,\n    );\n  }\n  return resolved;\n}\n\nexport type PageReactiveDataRootProps<TData, TVars extends OperationVariables> = Readonly<{\n  /** The composed PAGE_QUERY operation document. */\n  query: TypedDocumentNode<TData, TVars>;\n  /** Variables the server used when calling fetchPageData. Only used to seed the client cache. */\n  serverVariables?: TVars;\n  /** Server-rendered PAGE_QUERY result. When present and shape-matched, seeded into the cache once. */\n  initialData?: TData | null;\n  /** Reactive vars whose current values are merged into operation variables at render time. */\n  clientVariables?: ClientVariablesMap<TVars>;\n  children: ReactNode;\n}>;\n\nexport type ReactiveRootContextValue<TData = unknown> = Readonly<{\n  /** Current root query data exposed to descendant `ReactiveDataProvider`s. */\n  rootQueryData: TData | undefined;\n  /** Whether the underlying useQuery is currently in flight. */\n  loading: boolean;\n  /** False when at least one required variable has not been provided yet. */\n  hasAllRequiredVariables: boolean;\n  /**\n   * Error from the underlying useQuery. With non-null root fields (e.g. `cart: Cart!`), a failed\n   * fetch nulls the whole operation's `data` — descendants need this to tell \"fetch failed\" apart\n   * from \"entity is legitimately absent\" (specs/cart-context-client-migrate.md US-5).\n   */\n  error: ErrorLike | undefined;\n}>;\n\nexport const ReactiveRootContext = createContext<ReactiveRootContextValue>({\n  rootQueryData: undefined,\n  loading: false,\n  hasAllRequiredVariables: false,\n  error: undefined,\n});\n\nfunction getOperationDefinition(query: DocumentNode): OperationDefinitionNode | undefined {\n  for (const definition of query.definitions) {\n    if (definition.kind === Kind.OPERATION_DEFINITION) return definition;\n  }\n  return undefined;\n}\n\nfunction getRequiredVariableNames(query: DocumentNode): string[] {\n  const op = getOperationDefinition(query);\n  if (!op?.variableDefinitions) return [];\n  const required: string[] = [];\n  for (const def of op.variableDefinitions) {\n    if (def.type.kind === Kind.NON_NULL_TYPE && def.defaultValue === undefined) {\n      required.push(def.variable.name.value);\n    }\n  }\n  return required;\n}\n\nfunction getTopLevelFieldNames(query: DocumentNode): Set<string> {\n  const op = getOperationDefinition(query);\n  const names = new Set<string>();\n  if (!op) return names;\n  for (const sel of op.selectionSet.selections) {\n    if (sel.kind === Kind.FIELD) {\n      names.add((sel.alias ?? sel.name).value);\n    }\n  }\n  return names;\n}\n\nfunction shapeMatches(query: DocumentNode, data: unknown): boolean {\n  if (data == null || typeof data !== 'object') return false;\n  const expected = getTopLevelFieldNames(query);\n  if (expected.size === 0) return false;\n  const actual = data as Record<string, unknown>;\n  // Require AT LEAST ONE top-level field name to be present in `data`. The operation's full\n  // top-level shape may include fields the server did not return; partial seeds still help. A total\n  // miss (no overlap at all) signals a shape mismatch and we skip the seed.\n  for (const key of expected) {\n    if (key in actual) return true;\n  }\n  return false;\n}\n\n/**\n * Reads the current values of every reactive var in `clientVariables` into a plain object via a\n * single `useSyncExternalStore` call (no hooks-in-loop). Apollo's `ReactiveVar.onNextChange` fires\n * once per registration, so the subscriber re-attaches after each notification to stay listening.\n */\nfunction useClientVariableValues<TVars>(clientVariables: ClientVariablesMap<TVars> | undefined): Partial<TVars> {\n  // Keep the latest map identity reachable from inside subscribe()/getSnapshot() without forcing\n  // useSyncExternalStore to tear down the underlying subscription.\n  const varsRef = useRef(clientVariables);\n  // react-doctor-disable-next-line no-ref-current-in-render -- keeps the latest map reachable from the stable subscribe()/getSnapshot() callbacks below\n  varsRef.current = clientVariables;\n\n  const subscribe = useCallback((notify: () => void): (() => void) => {\n    const cv = varsRef.current;\n    if (!cv) return () => {};\n\n    const activeUnsubs: Array<() => void> = [];\n    let cancelled = false;\n\n    const attach = (rv: ReactiveVar<unknown>): void => {\n      if (cancelled) return;\n      const unsub = rv.onNextChange(() => {\n        notify();\n        // onNextChange fires only once — re-attach to keep listening for subsequent changes.\n        attach(rv);\n      });\n      activeUnsubs.push(unsub);\n    };\n\n    for (const rv of Object.values(cv)) {\n      if (rv === undefined || rv === null) continue;\n      const resolved = resolveReactiveVar(rv as ReactiveVar<unknown> | string);\n      if (resolved) attach(resolved);\n    }\n\n    return () => {\n      cancelled = true;\n      for (const u of activeUnsubs) u();\n    };\n  }, []);\n\n  const lastSnapshotRef = useRef<{ json: string; value: Record<string, unknown> } | null>(null);\n\n  const getSnapshot = (): string => {\n    const cv = varsRef.current;\n    const snap: Record<string, unknown> = {};\n    if (cv) {\n      for (const [key, reactiveVar] of Object.entries(cv)) {\n        if (reactiveVar === undefined || reactiveVar === null) continue;\n        const resolved = resolveReactiveVar(reactiveVar as ReactiveVar<unknown> | string);\n        if (!resolved) continue;\n        const value = resolved();\n        if (value !== null && value !== undefined) snap[key] = value;\n      }\n    }\n    const json = JSON.stringify(snap);\n    // useSyncExternalStore expects a stable snapshot reference until the value changes (Object.is\n    // identity check) — return the cached `json` whenever the contents are unchanged.\n    if (lastSnapshotRef.current && lastSnapshotRef.current.json === json) {\n      return lastSnapshotRef.current.json;\n    }\n    lastSnapshotRef.current = { json, value: snap };\n    return json;\n  };\n\n  useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n\n  return (lastSnapshotRef.current?.value ?? {}) as Partial<TVars>;\n}\n\nexport function PageReactiveDataRoot<TData = unknown, TVars extends OperationVariables = OperationVariables>(\n  props: PageReactiveDataRootProps<TData, TVars>,\n): ReactNode {\n  const { query, serverVariables, initialData, clientVariables, children } = props;\n  const client = useApolloClient();\n  const seededRef = useRef(false);\n\n  const clientValues = useClientVariableValues<TVars>(clientVariables);\n  const mergedVariables = { ...(serverVariables ?? ({} as TVars)), ...clientValues } as TVars;\n\n  const requiredNames = getRequiredVariableNames(query);\n  const mergedRecord = mergedVariables as Record<string, unknown>;\n  const hasAllRequiredVariables = requiredNames.every((name) => {\n    const v = mergedRecord[name];\n    return v !== null && v !== undefined;\n  });\n\n  // Ref- and shape-guarded one-time cache seed from server props. We use `useEffect` (not\n  // `useLayoutEffect`) to avoid the SSR-pass warning emitted by React 19 — the resulting \"first\n  // render shows fallbackData, second render shows cache slice\" behaviour is acceptable because\n  // initialData is the same value `ReactiveDataProvider` falls back to anyway.\n  useEffect(() => {\n    if (seededRef.current) return;\n    if (!serverVariables || initialData == null) return;\n    if (!shapeMatches(query, initialData)) return;\n    client.cache.writeQuery({ query, variables: serverVariables, data: initialData });\n    seededRef.current = true;\n  }, [client, query, serverVariables, initialData]);\n\n  const { data, loading, error } = useQuery(query, {\n    variables: mergedVariables,\n    fetchPolicy: 'cache-first',\n    skip: !hasAllRequiredVariables,\n  });\n\n  const contextValue: ReactiveRootContextValue<TData> = useMemo(\n    () => ({\n      rootQueryData: (data ?? undefined) as TData | undefined,\n      loading,\n      hasAllRequiredVariables,\n      error,\n    }),\n    [data, loading, hasAllRequiredVariables, error],\n  );\n\n  return (\n    <ReactiveRootContext.Provider value={contextValue as ReactiveRootContextValue}>\n      {children}\n    </ReactiveRootContext.Provider>\n  );\n}\n"],"mappings":"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"}

package/dist/sdk/data/reactive-data-provider.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from "react";
+import { DocumentNode } from "@apollo/client";
+//#region src/sdk/data/reactive-data-provider.d.ts
+export type ReactiveDataProviderProps = Readonly<{
+  /** Derived `fragment <X>_<EntityType> on <EntityType>` document emitted by the compiler. */
+  entityFragment: DocumentNode;
+  /** Name of the derived fragment, passed to `useFragment`. */
+  fragmentName: string;
+  /** Top-level field of the page query (e.g. 'cart') used to extract the entity ref. */
+  rootField: string;
+  /** Server-rendered fragment payload; used until the cache resolves a complete entity slice. */
+  fallbackData: unknown;
+  children: ReactNode;
+}>;
+/**
+ * Per-particle reactive subscriber (AD-4 / AD-D2).
+ *
+ * Resolves its entity slice via `useReactiveEntity` (the shared single-entity resolve; see that
+ * hook's doc for the cache-read details) and writes it, unmodified, into `DataOverrideContext`.
+ *
+ * See specs/reactive-data-flow.md (AD-4, AD-D2) and rfc-data-layer.md §"Reactive fetch".
+ */
+export declare function ReactiveDataProvider({ entityFragment, fragmentName, rootField, fallbackData, children }: ReactiveDataProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=reactive-data-provider.d.ts.map

package/dist/sdk/data/reactive-data-provider.js

@@ -0,0 +1,24 @@
+"use client";
+import { DataOverrideContext } from "./data-override-context.js";
+import { useReactiveEntity } from "./use-reactive-entity.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/sdk/data/reactive-data-provider.tsx
+/**
+* Per-particle reactive subscriber (AD-4 / AD-D2).
+*
+* Resolves its entity slice via `useReactiveEntity` (the shared single-entity resolve; see that
+* hook's doc for the cache-read details) and writes it, unmodified, into `DataOverrideContext`.
+*
+* See specs/reactive-data-flow.md (AD-4, AD-D2) and rfc-data-layer.md §"Reactive fetch".
+*/
+function ReactiveDataProvider({ entityFragment, fragmentName, rootField, fallbackData, children }) {
+	const resolved = useReactiveEntity(entityFragment, fragmentName, rootField, fallbackData);
+	return /* @__PURE__ */ jsx(DataOverrideContext, {
+		value: resolved,
+		children
+	});
+}
+//#endregion
+export { ReactiveDataProvider };
+
+//# sourceMappingURL=reactive-data-provider.js.map

package/dist/sdk/data/reactive-data-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-data-provider.js","names":[],"sources":["../../../src/sdk/data/reactive-data-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { DocumentNode } from '@apollo/client';\nimport type { ReactNode } from 'react';\nimport { DataOverrideContext } from './data-override-context.js';\nimport { useReactiveEntity } from './use-reactive-entity.js';\n\nexport type ReactiveDataProviderProps = Readonly<{\n  /** Derived `fragment <X>_<EntityType> on <EntityType>` document emitted by the compiler. */\n  entityFragment: DocumentNode;\n  /** Name of the derived fragment, passed to `useFragment`. */\n  fragmentName: string;\n  /** Top-level field of the page query (e.g. 'cart') used to extract the entity ref. */\n  rootField: string;\n  /** Server-rendered fragment payload; used until the cache resolves a complete entity slice. */\n  fallbackData: unknown;\n  children: ReactNode;\n}>;\n\n/**\n * Per-particle reactive subscriber (AD-4 / AD-D2).\n *\n * Resolves its entity slice via `useReactiveEntity` (the shared single-entity resolve; see that\n * hook's doc for the cache-read details) and writes it, unmodified, into `DataOverrideContext`.\n *\n * See specs/reactive-data-flow.md (AD-4, AD-D2) and rfc-data-layer.md §\"Reactive fetch\".\n */\nexport function ReactiveDataProvider({\n  entityFragment,\n  fragmentName,\n  rootField,\n  fallbackData,\n  children,\n}: ReactiveDataProviderProps): ReactNode {\n  const resolved = useReactiveEntity(entityFragment, fragmentName, rootField, fallbackData);\n\n  return <DataOverrideContext value={resolved}>{children}</DataOverrideContext>;\n}\n"],"mappings":";;;;;;;;;;;;;AA2BA,SAAgB,qBAAqB,EACnC,gBACA,cACA,WACA,cACA,YACuC;CACvC,MAAM,WAAW,kBAAkB,gBAAgB,cAAc,WAAW,YAAY;CAExF,OAAO,oBAAC,qBAAD;EAAqB,OAAO;EAAW;CAA8B,CAAA;AAC9E"}

package/dist/sdk/data/reactive-list-item-data-provider.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from "react";
+import { DocumentNode } from "@apollo/client";
+//#region src/sdk/data/reactive-list-item-data-provider.d.ts
+export type ReactiveListItemDataProviderProps = Readonly<{
+  /** Derived `fragment <X>_<ListElementEntity> on <ListElementEntity>` document emitted by the compiler. */
+  entityFragment: DocumentNode;
+  /** Name of the derived fragment, passed to `useFragment`. */
+  fragmentName: string;
+  children: ReactNode;
+}>;
+/**
+ * Per-iterated-line reactive subscriber.
+ *
+ * The list-item sibling of `ReactiveDataProvider`: instead of deriving the entity ref from a
+ * top-level page-query field, it reads the current line's ref from `ListItemRefContext` (published
+ * per line by the iterator, e.g. `CartList`) and subscribes to that one normalized entity
+ * (`CartItem:<id>`) via `useFragment`. The hook never triggers a network request — it is purely a
+ * cache reader. When the ref is unresolved or the cache slice is incomplete, it falls back to the
+ * line's server-rendered slice (`fallbackData`) so descendants always see a value. The resolved
+ * slice is published through the same `DataOverrideContext` seam reactive components read today.
+ *
+ * See specs/fspg-816-minicart-compiler-per-item-composition.md.
+ */
+export declare function ReactiveListItemDataProvider({ entityFragment, fragmentName, children }: ReactiveListItemDataProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=reactive-list-item-data-provider.d.ts.map