@amplifyup/sdk 0.1.61 → 0.1.63

package/dist/AmplifyRenderer.d.ts

@@ -1,40 +1,4 @@
-import * as React from 'react';
-import { ReactNode } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { P as PageConfig } from './types-Db_eLrfU.js';
-
-interface AmplifyRendererProps {
-    /**
-     * Component renderer function that maps componentId to React component
-     * This is site-specific and must be provided by the developer
-     */
-    renderComponent: (componentId: string, props: Record<string, any>, slots?: Record<string, ReactNode>, context?: {
-        layoutNodeId: string;
-    }) => ReactNode;
-    /**
-     * Optional page config for server-side rendering (SSR/SSG)
-     * If provided, the component will use this instead of fetching client-side
-     */
-    pageConfig?: PageConfig;
-    /**
-     * Optional loading component
-     */
-    loadingComponent?: ReactNode;
-    /**
-     * Optional error component
-     */
-    errorComponent?: (error: string) => ReactNode;
-    /**
-     * Optional empty state component (when no content is configured)
-     */
-    emptyComponent?: ReactNode;
-    /**
-     * Force Composer page-slot wrapper (avoids SSR miss when window isn't available yet).
-     * When true, root components stay under [data-slot-source="page"] so hierarchy can climb to Page.
-     */
-    composerPreview?: boolean;
-}
-declare function AmplifyRendererInner({ renderComponent, pageConfig: serverPageConfig, loadingComponent, errorComponent, emptyComponent, composerPreview, }: AmplifyRendererProps): react_jsx_runtime.JSX.Element | null;
-declare const AmplifyRenderer: React.MemoExoticComponent<typeof AmplifyRendererInner>;
-
-export { AmplifyRenderer };
+import 'react';
+import 'react/jsx-runtime';
+export { A as AmplifyRenderer } from './AmplifyRenderer-Bwob7ICJ.js';
+import './types-Db_eLrfU.js';

package/dist/AmplifyRenderer.js

@@ -407,6 +407,159 @@ function isComposerPreview() {
   return false;
 }
 
+// src/field-envelope.ts
+var FIELDS_BRAND = Symbol("amplifyup.fields");
+function isBrandedFields(value) {
+  return !!value && typeof value === "object" && FIELDS_BRAND in value;
+}
+function brandFields(bag) {
+  if (isBrandedFields(bag)) return bag;
+  Object.defineProperty(bag, FIELDS_BRAND, {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return bag;
+}
+function isFieldEnvelope(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const rec = value;
+  return typeof rec.name === "string" && "value" in rec && !("url" in rec);
+}
+function isPortableImageShape(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return "url" in value;
+}
+function isEntryRefItem(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const rec = value;
+  return typeof rec.id === "string" && rec.id.trim().length > 0 || typeof rec._id === "string" && rec._id.trim().length > 0 || typeof rec.docId === "string" && rec.docId.trim().length > 0;
+}
+function isRepeaterArray(value) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  const sample = value.find((item) => item != null);
+  if (sample === void 0) return false;
+  if (typeof sample !== "object" || Array.isArray(sample)) return false;
+  if (isPortableImageShape(sample)) return false;
+  if (isEntryRefItem(sample)) return false;
+  if (sample.$$typeof) return false;
+  return true;
+}
+function joinPath(prefix, key) {
+  return prefix ? `${prefix}.${key}` : key;
+}
+function emptyValue(raw) {
+  if (raw === void 0) return null;
+  return raw;
+}
+function toFieldEnvelopes(source, prefix = "") {
+  const input = source && typeof source === "object" && !Array.isArray(source) ? source : {};
+  if (isBrandedFields(input)) {
+    return input;
+  }
+  const out = {};
+  for (const [key, raw] of Object.entries(input)) {
+    const path = joinPath(prefix, key);
+    if (isFieldEnvelope(raw)) {
+      const inner = raw.value;
+      if (isRepeaterArray(inner)) {
+        out[key] = {
+          value: envelopeRepeaterItems(inner, raw.name || path),
+          name: raw.name || path
+        };
+        continue;
+      }
+      out[key] = { value: raw.value ?? null, name: raw.name || path };
+      continue;
+    }
+    if (isRepeaterArray(raw)) {
+      out[key] = { value: envelopeRepeaterItems(raw, path), name: path };
+      continue;
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw) && !isPortableImageShape(raw) && !raw.$$typeof) {
+      out[key] = toFieldEnvelopes(raw, path);
+      continue;
+    }
+    out[key] = { value: emptyValue(raw), name: path };
+  }
+  return brandFields(out);
+}
+function envelopeRepeaterItems(items, prefix) {
+  return items.map((item, i) => {
+    const path = joinPath(prefix, String(i));
+    if (isBrandedFields(item)) return item;
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      return toFieldEnvelopes(item, path);
+    }
+    return toFieldEnvelopes({}, path);
+  });
+}
+function attachFieldEnvelopes(props) {
+  const raw = props && typeof props === "object" ? { ...props } : {};
+  if (isBrandedFields(raw.fields)) return raw;
+  const { fields: existing, ...content } = raw;
+  const source = existing && typeof existing === "object" && !isFieldEnvelope(existing) ? existing : content;
+  return { ...raw, fields: toFieldEnvelopes(source) };
+}
+function walkLayoutNodes(nodes) {
+  if (!Array.isArray(nodes)) return;
+  for (const node of nodes) {
+    if (!node || typeof node !== "object") continue;
+    const rec = node;
+    rec.props = attachFieldEnvelopes(rec.props);
+    for (const slot of rec.slots || []) {
+      walkLayoutNodes(slot.children);
+    }
+  }
+}
+function envelopePageConfig(page) {
+  if (!page || typeof page !== "object") return page ?? null;
+  const tree = page.layoutTree;
+  if (Array.isArray(tree)) walkLayoutNodes(tree);
+  return page;
+}
+function collectFieldPatches(props) {
+  const out = [];
+  const walkRepeater = (items, prefix) => {
+    items.forEach((item, i) => {
+      const itemPath = joinPath(prefix, String(i));
+      if (isBrandedFields(item) || item && typeof item === "object" && !Array.isArray(item) && !isFieldEnvelope(item)) {
+        walk(item, itemPath);
+      }
+    });
+  };
+  const walk = (obj, prefix) => {
+    for (const [key, raw] of Object.entries(obj)) {
+      if (key === "fields" && raw && typeof raw === "object" && !Array.isArray(raw) && !isFieldEnvelope(raw)) {
+        walk(raw, prefix);
+        continue;
+      }
+      const path = joinPath(prefix, key);
+      if (isFieldEnvelope(raw)) {
+        if (isRepeaterArray(raw.value)) {
+          walkRepeater(raw.value, raw.name || path);
+          continue;
+        }
+        out.push({ name: raw.name || path, value: raw.value });
+        continue;
+      }
+      if (isRepeaterArray(raw)) {
+        walkRepeater(raw, path);
+        continue;
+      }
+      if (raw && typeof raw === "object" && !Array.isArray(raw) && !isPortableImageShape(raw) && !raw.$$typeof) {
+        walk(raw, path);
+        continue;
+      }
+      out.push({ name: path, value: emptyValue(raw) });
+    }
+  };
+  if (props && typeof props === "object" && !Array.isArray(props)) {
+    walk(props, "");
+  }
+  return out;
+}
+
 // src/page-context.ts
 var defaultLog = {
   warn: (...args) => {
@@ -555,7 +708,70 @@ function mergeEventContext(properties, attached) {
     ...attached.pageRoute ? { pageRoute: attached.pageRoute } : {}
   };
 }
+var PAGE_RESOURCE_MARKER = "__amplifyupPageResource";
+function isPageResourceSentinel(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && typeof value[PAGE_RESOURCE_MARKER] === "string";
+}
+function getByDotPath(source, path) {
+  if (!path) return source;
+  const parts = path.split(".").filter(Boolean);
+  let cur = source;
+  for (const part of parts) {
+    if (cur == null || typeof cur !== "object" || Array.isArray(cur)) {
+      return void 0;
+    }
+    cur = cur[part];
+  }
+  return cur;
+}
+function hydratePageResourceValue(value, fields) {
+  if (!isPageResourceSentinel(value)) return value;
+  if (!fields) return null;
+  if (value.path) return getByDotPath(fields, value.path) ?? null;
+  return fields;
+}
+function hydrateFieldsBag(bag, fields) {
+  const out = {};
+  for (const [key, val] of Object.entries(bag)) {
+    if (val && typeof val === "object" && !Array.isArray(val) && typeof val.name === "string" && "value" in val && !("url" in val)) {
+      const env = val;
+      out[key] = {
+        name: env.name,
+        value: isPageResourceSentinel(env.value) ? hydratePageResourceValue(env.value, fields) : env.value
+      };
+      continue;
+    }
+    if (val && typeof val === "object" && !Array.isArray(val) && !("url" in val)) {
+      out[key] = hydrateFieldsBag(val, fields);
+      continue;
+    }
+    out[key] = isPageResourceSentinel(val) ? hydratePageResourceValue(val, fields) : val;
+  }
+  return out;
+}
+function hydratePageResourceProps(props, fields) {
+  const source = props && typeof props === "object" ? props : {};
+  const out = { ...source };
+  if (out.fields && typeof out.fields === "object" && !Array.isArray(out.fields)) {
+    const next = hydrateFieldsBag(out.fields, fields);
+    out.fields = isBrandedFields(out.fields) ? brandFields(next) : next;
+  }
+  for (const [key, val] of Object.entries(out)) {
+    if (key === "fields") continue;
+    if (isPageResourceSentinel(val)) {
+      out[key] = hydratePageResourceValue(val, fields);
+    }
+  }
+  return out;
+}
+
+// src/page-resource-runtime.ts
+var pageResourceFields = null;
 function setPageResourceFields(fields) {
+  pageResourceFields = fields && typeof fields === "object" ? fields : null;
+}
+function getPageResourceFields() {
+  return pageResourceFields;
 }
 
 // src/debug.ts
@@ -1238,6 +1454,7 @@ var AmplifyUpSDK = class {
         this.resolvedPageData,
         this.resolvedPageRoute
       );
+      setPageResourceFields(null);
       return;
     }
     this.attachedPageContext = applyPageContext(this.pendingPageContext, {
@@ -1666,7 +1883,7 @@ Available Console Commands:
         this.refreshEventTracking();
       }, 800);
     }
-    return pageConfig;
+    return envelopePageConfig(pageConfig);
   }
   /**
    * Set up view-level event tracking based on configuration
@@ -3039,31 +3256,83 @@ function getSDK(adapter) {
 var trackContentView = (contentId, contentType, properties) => getSDK().trackContentView(contentId, contentType, properties);
 var refreshEventTracking = () => getSDK().refreshEventTracking();
 getSDK();
-react.createContext(null);
-function useLiveComposerProps(layoutNodeId, props) {
-  const [patch, setPatch] = react.useState(null);
-  react.useEffect(() => {
-    setPatch(null);
-    const matchesNode = (nodeId) => {
-      if (nodeId && layoutNodeId && String(nodeId) !== String(layoutNodeId)) {
-        return false;
-      }
-      return true;
+
+// src/composer-store.ts
+var ComposerFieldStore = class {
+  constructor() {
+    this.values = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  get(name) {
+    return this.values.has(name) ? this.values.get(name) : void 0;
+  }
+  set(name, value) {
+    if (!name) return;
+    this.values.set(name, value);
+    const set = this.listeners.get(name);
+    if (!set) return;
+    for (const fn of set) fn();
+  }
+  subscribe(name, fn) {
+    if (!name) return () => {
+    };
+    let set = this.listeners.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(name, set);
+    }
+    set.add(fn);
+    return () => {
+      set.delete(fn);
+      if (set.size === 0) this.listeners.delete(name);
     };
+  }
+  keys() {
+    return [...this.values.keys()];
+  }
+  delete(name) {
+    if (!name || !this.values.has(name)) return;
+    this.values.delete(name);
+    const set = this.listeners.get(name);
+    if (!set) return;
+    for (const fn of set) fn();
+  }
+};
+var ComposerStoreContext = react.createContext(null);
+function matchesNode(eventNodeId, layoutNodeId) {
+  if (eventNodeId && layoutNodeId && String(eventNodeId) !== String(layoutNodeId)) {
+    return false;
+  }
+  return true;
+}
+function ComposerProvider({
+  layoutNodeId,
+  children
+}) {
+  const storeRef = react.useRef(null);
+  if (!storeRef.current) storeRef.current = new ComposerFieldStore();
+  const store = storeRef.current;
+  react.useEffect(() => {
     const applyField = (fieldName, value, nodeId) => {
       if (!fieldName || typeof fieldName !== "string") return;
-      if (!matchesNode(nodeId)) return;
-      setPatch((prev) => ({ ...prev || {}, [fieldName]: value }));
+      if (!matchesNode(nodeId, layoutNodeId)) return;
+      store.set(fieldName, value);
+      if (value && typeof value === "object") {
+        for (const patch of collectFieldPatches(
+          toFieldEnvelopes({ [fieldName]: value })
+        )) {
+          store.set(patch.name, patch.value);
+        }
+      }
     };
     const applyProps = (nextProps, nodeId) => {
       if (!nextProps || typeof nextProps !== "object" || Array.isArray(nextProps)) {
         return;
       }
-      if (!matchesNode(nodeId)) return;
-      setPatch((prev) => ({
-        ...prev || {},
-        ...nextProps
-      }));
+      if (!matchesNode(nodeId, layoutNodeId)) return;
+      for (const patch of collectFieldPatches(nextProps)) {
+        store.set(patch.name, patch.value);
+      }
     };
     const onPatch = (event) => {
       const detail = event.detail || {};
@@ -3089,9 +3358,19 @@ function useLiveComposerProps(layoutNodeId, props) {
       window.removeEventListener("amplifyup:props-patch", onPropsPatch);
       window.removeEventListener("message", onMessage);
     };
-  }, [layoutNodeId]);
-  return patch ? { ...props, ...patch } : props;
+  }, [layoutNodeId, store]);
+  return /* @__PURE__ */ jsxRuntime.jsx(ComposerStoreContext.Provider, { value: store, children });
+}
+function MaybeComposerProvider({
+  enabled,
+  layoutNodeId,
+  children
+}) {
+  const content = react.useMemo(() => children, [children]);
+  if (!enabled) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: content });
+  return /* @__PURE__ */ jsxRuntime.jsx(ComposerProvider, { layoutNodeId, children });
 }
+react.createContext(null);
 var usePathname = null;
 if (typeof window !== "undefined") {
   try {
@@ -3111,9 +3390,19 @@ function useAmplifyUp() {
   return context;
 }
 function nodeRenderProps(node) {
+  const settings = node.settings || {};
+  const hydrated = hydratePageResourceProps(
+    node.props || {},
+    getPageResourceFields()
+  );
+  const fields = hydrated.fields;
+  const branded = isBrandedFields(fields) ? fields : brandFields(
+    fields && typeof fields === "object" ? fields : {}
+  );
   return {
-    ...node.settings || {},
-    ...node.props || {}
+    ...settings,
+    ...hydrated,
+    fields: branded
   };
 }
 var ComponentRenderBoundary = class extends react.Component {
@@ -3163,17 +3452,24 @@ var ComponentRenderBoundary = class extends react.Component {
     return this.props.children;
   }
 };
-function LiveNodeRender({
+function NodeWithFields({
   nodeId,
   componentId,
   props,
   slots,
-  renderComponent
+  renderComponent,
+  composerPreview
 }) {
-  const liveProps = useLiveComposerProps(nodeId, props);
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderComponent(componentId, liveProps, slots, {
-    layoutNodeId: nodeId
-  }) });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    MaybeComposerProvider,
+    {
+      enabled: !!(composerPreview || isComposerPreview()),
+      layoutNodeId: nodeId,
+      children: renderComponent(componentId, props, slots, {
+        layoutNodeId: nodeId
+      })
+    }
+  );
 }
 function AmplifyRendererInner({
   renderComponent,
@@ -3529,13 +3825,14 @@ function AmplifyRendererInner({
             componentId: node.componentId,
             nodeId: node.id,
             children: /* @__PURE__ */ jsxRuntime.jsx(
-              LiveNodeRender,
+              NodeWithFields,
               {
                 nodeId: node.id,
                 componentId: node.componentId,
                 props: nodeRenderProps(node),
                 slots: slotsToPass,
-                renderComponent
+                renderComponent,
+                composerPreview
               }
             )
           }