@contentful/experiences-sdk-react 3.8.0-dev-20250926T1559-e1ab24d.0 → 3.8.0-prerelease-20250926T1312-a8b5fb7.0

package/dist/core/preview/PrebindingManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrebindingManager.js","sources":["../../../../src/core/preview/PrebindingManager.ts"],"sourcesContent":["import {\n  ExperienceComponentSettings,\n  ParameterDefinition,\n  VariableMapping,\n} from '@contentful/experiences-core/types';\n\nconst NODE_ID_SEPARATOR = '---'; // separator used to separate pattern levels in deseralizePatternNode\n\nexport type ParameterDefinitionWithParameterId = {\n  parameterId: string;\n  parameter: ParameterDefinition;\n};\ntype ParameterOverride = {\n  overwrittenByParamId: string;\n  originalNodeIdToOverride: string;\n  indexedParentPatternNodeId: string;\n};\n\n/**\n * PrebindingManager utility class for resolving parameter bindings across nested patterns.\n *\n * The core approach is to first resolve the top-level parameterId using `getParameterIdByNodeId`,\n * which uses the paramIdToOverwriteIdMap, set when storing pre-binding based on the passToNodes chain to determine which parameter in the parent pattern\n * overrides a given parameterId (with some additionally workaround due to node ID renaming for patterns).\n * Once the owning top-level `parameterId` is found, we can follow the `passToNodes` chain back\n * down to retrieve all nested overrides — including parameter definitions, allowed content types,\n * and default sources — up to three levels deep.\n *\n * ## Lifecycle\n * This utility class currently uses static state, with Zustand stores supplementing the “latest” data\n * for root-level patterns data — for example, when overwriting content types on nested patterns or binding\n * fields on simple patterns. If we need the override mappings to be reactive, we could easily move\n * the full override chain tracking into Zustand but currently we can rely on the pattern definition\n * stores we have currently.\n *\n * The state is populated during deserialization, where we call `storePrebindingDefinitions` for each\n * pattern node. It is ready to be consumed at each level as nodes are deserialized top-down:\n * 1. Pattern C (Template Pattern)\n * 2. Pattern B (Nested Pattern)\n * 3. Pattern A (Simple Pattern)\n *\n * At each level, accessing overrides is possible:\n * - Pattern C has everything it needs once deserialized with its own parameters\n * - Pattern B has everything it needs once deserialized, with its own parameters possibly overridden by C\n * - Pattern A has its own parameters and possiblle overrites by B and/or C\n *\n * After actions that modify patterns without re-deserializing the tree — such as duplication,\n * deletion, or detachment — this state must be kept up to date via storePrebindingDefinitions\n * or storeParameterDefinitions if only parameter definitions are updated.\n *\n * ## Core Data Structures\n *\n *  - prebindingDefinitions           - A collection of all prebinding definitions aggregated\n *                                       from the parent pattern down to all nested patterns.\n *\n *  - prebindingDefinitionIdsByNodeId - Same as above, but indexed by `nodeId`. This allows us\n *                                       to easily find the prebinding definition id for a given node ID.\n *\n *  - parameterDefinitionsById        - A collection of all parameter definitions aggregated\n *                                       from the parent pattern down to nested patterns.\n *\n *  - variableMappingByPatternId      - A collection of all variable mappings aggregated from\n *                                       the parent pattern down to nested patterns, indexed by\n *                                       `patternId` for efficient access.\n *\n *  - newToOriginalNodeIdMap          - When deserializing pattern child nodes, we replace their\n *                                       node IDs with new ones based on their location inside the\n *                                       pattern. This prevents conflicts when multiple instances\n *                                       of the same pattern exist. The issue is that prebinding\n *                                       `passToNodes` resolution requires the original node ID.\n *                                       This map allows us to retrieve it to follow the chain.\n *\n *  - paramIdToOverwriteIdMap         - Tracks parameter ID overrides through the `passToNodes`\n *                                       chain, allowing us to resolve overrides correctly from\n *                                       the top-level parameter down to the lowest-level.\n */\nexport class PrebindingManager {\n  private static prebindingDefinitions: Map<\n    string,\n    NonNullable<ExperienceComponentSettings['prebindingDefinitions']>[number]\n  > = new Map();\n  private static prebindingDefinitionIdsByNodeId: Map<string, string[]> = new Map();\n  private static parameterDefinitionsById: Map<string, ParameterDefinitionWithParameterId> =\n    new Map();\n  private static parameterDefinitionsByNodeId: Map<string, ParameterDefinitionWithParameterId[]> =\n    new Map();\n  private static variableMappingByPatternId: Map<string, Record<string, VariableMapping>> =\n    new Map();\n  private static newToOriginalNodeIdMap = new Map<string, string>();\n  private static paramIdToOverwriteIdMap = new Map<string, Array<ParameterOverride>>();\n\n  /**\n   * Links new node IDs to original node IDs\n   * - This is used to track the original node IDs for pattern instances as we change them when deserializing pattern nodes.\n   * @param newNodeId\n   * @param originalNodeId\n   */\n  public static linkOriginalNodeIds(newNodeId: string, originalNodeId: string) {\n    PrebindingManager.newToOriginalNodeIdMap.set(newNodeId, originalNodeId);\n  }\n\n  /**\n   * Initializes the pattern editor manager by storing the definitions during deserialization\n   * for the root pattern and all nested patterns.\n   *\n   * @param nodeId - The ID of the pattern node.\n   * @param patternEntryId - The ID of the pattern entry from the patterns store.\n   * @param prebindingDefinitions - The prebinding definitions from the current pattern's component settings.\n   */\n  public static storePrebindingDefinitions(\n    nodeId: string,\n    patternEntryId: string,\n    prebindingDefinitions: NonNullable<ExperienceComponentSettings['prebindingDefinitions']>,\n  ) {\n    for (const definition of prebindingDefinitions ?? []) {\n      PrebindingManager.prebindingDefinitions.set(definition.id, { ...definition });\n      PrebindingManager.prebindingDefinitionIdsByNodeId.set(nodeId, [definition.id]); // can only be one right now\n\n      if (definition.variableMappings) {\n        PrebindingManager.variableMappingByPatternId.set(\n          patternEntryId,\n          definition.variableMappings,\n        );\n      }\n      // Store the parameter definitions for the node\n      PrebindingManager.storeParameterDefinitions(nodeId, definition.parameterDefinitions || {});\n    }\n  }\n\n  /**\n   * Stores parameter definitions for a given nodeId.\n   * @param nodeId - The ID of the node to store parameter definitions for.\n   * @param parameterDefinitions - The parameter definitions to store.\n   */\n  public static storeParameterDefinitions(\n    nodeId: string,\n    parameterDefinitions?: Record<string, ParameterDefinition>,\n  ) {\n    // Reset the list of parameter definitions for the nodeId\n    PrebindingManager.parameterDefinitionsByNodeId.set(nodeId, []);\n    const updatedParameterDefinitionsByNodeId: ParameterDefinitionWithParameterId[] = [];\n\n    for (const [parameterId, parameter] of Object.entries(parameterDefinitions || {})) {\n      PrebindingManager.parameterDefinitionsById.set(parameterId, {\n        parameterId,\n        parameter,\n      });\n\n      if (parameter.passToNodes) {\n        const { parameterId: paramIdToOverwrite, nodeId: targetNodeId } =\n          parameter.passToNodes[0] ?? {};\n\n        if (paramIdToOverwrite) {\n          const existing = PrebindingManager.paramIdToOverwriteIdMap.get(paramIdToOverwrite) ?? [];\n          const hasMatchingOverride = existing.some(\n            (it) =>\n              it.overwrittenByParamId === parameterId &&\n              it.originalNodeIdToOverride === targetNodeId &&\n              it.indexedParentPatternNodeId === nodeId,\n          );\n\n          // Only add the override if it doesn't already exist to save duplicates\n          if (!hasMatchingOverride) {\n            PrebindingManager.paramIdToOverwriteIdMap.set(paramIdToOverwrite, [\n              ...existing,\n              {\n                overwrittenByParamId: parameterId,\n                originalNodeIdToOverride: targetNodeId,\n                indexedParentPatternNodeId: nodeId,\n              },\n            ]);\n          }\n        }\n      }\n      updatedParameterDefinitionsByNodeId.push({ parameterId, parameter });\n    }\n    PrebindingManager.parameterDefinitionsByNodeId.set(nodeId, updatedParameterDefinitionsByNodeId);\n  }\n\n  /**\n   * Resolves the top-level parameterId for a given nodeId.\n   *\n   * @param nodeId - The nodeId to resolve the parameterId for\n   * @param useStoreParameters - Whether to use the zustand store parameters or not\n   * @returns string | undefined - The resolved parameterId or undefined if not found\n   **/\n  public static getParameterIdByNodeId(nodeId: string): string | undefined {\n    const nativeParameterDefinitionForNodeId =\n      PrebindingManager.getNativeParameterDefinitionByNodeId(nodeId);\n\n    if (!nativeParameterDefinitionForNodeId) {\n      return undefined;\n    }\n    const hoistedParameterId = PrebindingManager.getHoistedIdForParameterId(\n      nativeParameterDefinitionForNodeId?.parameterId,\n      nodeId,\n    );\n\n    return hoistedParameterId;\n  }\n\n  /* Returns the parameter definitions from a parameterId\n   * @param parameterId - The parameter to resolve all levels for\n   * @param useStoreParameters - Whether to use the zustand store parameters or not\n   * @returns [l1ParameterDefinitions, l2ParameterDefinitions, l3ParameterDefinitions]: Array of parameter definitions for each level\n   */\n  public static getParameterDefinitionsByParameterId(\n    parameterId: string,\n  ): (ParameterDefinitionWithParameterId | undefined)[] | undefined {\n    const l1Definition = PrebindingManager.parameterDefinitionsById.get(parameterId);\n\n    const l1PassToNode = (l1Definition?.parameter?.passToNodes || [])[0];\n    // Level 2\n    const l2Definition = PrebindingManager.parameterDefinitionsById.get(l1PassToNode?.parameterId);\n    const l2PassToNode = (l2Definition?.parameter?.passToNodes || [])[0];\n    let l3Definition: ParameterDefinitionWithParameterId | undefined;\n    // Level 3\n    if (l2PassToNode) {\n      // If the child definition has passToNodes, we can look up the child parameter definition by its composite key\n      l3Definition = PrebindingManager.parameterDefinitionsById.get(l2PassToNode?.parameterId);\n    }\n    // Return the definitions for all three levels unless they are all empty\n    const definitions = [l1Definition, l2Definition, l3Definition];\n    if (!definitions || !definitions.filter(Boolean).length) {\n      return undefined; // No definitions found\n    }\n    return definitions;\n  }\n\n  /**\n   * Returns all parameter definitions defined on the pattern of the given nodeId OR the pattern, wrapping the given nodeId\n   */\n  public static getAllParameterDefinitionsForNodeId(nodeId: string) {\n    return Object.fromEntries(\n      (PrebindingManager.parameterDefinitionsByNodeId.get(nodeId) ?? []).map(\n        ({ parameterId, parameter }) => [parameterId, parameter],\n      ),\n    );\n  }\n\n  /**\n   * Return all parameter ID's on a pattern by NodeId\n   * @param nodeId - The nodeId to return params for\n   * @returns string[] An array of parameter IDs or undefined\n   */\n  public static getAllParameterIdsByNodeId(nodeId: string): string[] | undefined {\n    return Object.keys(PrebindingManager.getAllParameterDefinitionsForNodeId(nodeId));\n  }\n\n  /**\n   * Get the highest level overriding parameterId for a given parameterId + nodeId combination\n   * @param parameterId - The parameter to resolve\n   * @param indexedNodeId - The indexed node ID to resolve the parameterId for\n   * @returns string - The resolved parameterId - will be from \"root\" in patterns or the parent pattern node in experiences\n   */\n  public static getHoistedIdForParameterId(parameterId: string, indexedNodeId: string): string {\n    let currentParamId = parameterId;\n    let currentIndexedNodeId = indexedNodeId;\n    let currentOriginalNodeId: string | undefined =\n      PrebindingManager.newToOriginalNodeIdMap.get(indexedNodeId) ?? indexedNodeId;\n    let override: ParameterOverride | undefined;\n\n    do {\n      const overrides = PrebindingManager.paramIdToOverwriteIdMap.get(currentParamId) ?? [];\n      const splitByDash = currentIndexedNodeId.split(NODE_ID_SEPARATOR);\n      override = overrides.find(\n        (it) =>\n          it.originalNodeIdToOverride === currentOriginalNodeId &&\n          ((splitByDash.length > 1 &&\n            currentIndexedNodeId.includes(it.indexedParentPatternNodeId)) ||\n            (splitByDash.length === 1 && it.indexedParentPatternNodeId === 'root')),\n      );\n      if (override) {\n        const { overwrittenByParamId, indexedParentPatternNodeId } = override;\n        currentParamId = overwrittenByParamId;\n        currentIndexedNodeId = indexedParentPatternNodeId;\n        currentOriginalNodeId =\n          PrebindingManager.newToOriginalNodeIdMap.get(indexedParentPatternNodeId) ??\n          indexedParentPatternNodeId;\n      }\n    } while (override);\n\n    return currentParamId;\n  }\n\n  /**\n   * Retrieves the native parameter definition for a given nodeId. ie one without passToNodes on the node.\n   * @param nodeId - The nodeId to retrieve the native parameter definition for\n   * @returns The native parameter definition for the given nodeId, or undefined if not found\n   */\n  public static getNativeParameterDefinitionByNodeId(\n    nodeId: string,\n  ): ParameterDefinitionWithParameterId | undefined {\n    const parameterDefinitionsForNodeId =\n      PrebindingManager.parameterDefinitionsByNodeId.get(nodeId);\n    return PrebindingManager.extractNativeParameterDefinition(parameterDefinitionsForNodeId);\n  }\n\n  private static extractNativeParameterDefinition(\n    parameterDefinitions: ParameterDefinitionWithParameterId[] | undefined,\n  ): ParameterDefinitionWithParameterId | undefined {\n    const { parameterId, parameter } =\n      parameterDefinitions?.find((it) => !it.parameter.passToNodes?.length) || {};\n    if (!parameterId || !parameter) return;\n    return {\n      parameterId,\n      parameter,\n    };\n  }\n\n  /**\n   * Resets all properties of the PrebindingManager class\n   * triggered when we leave ExperienceBuilder back to experience folder view.\n   **/\n  public static reset() {\n    PrebindingManager.prebindingDefinitions = new Map();\n    PrebindingManager.parameterDefinitionsById = new Map();\n    PrebindingManager.parameterDefinitionsByNodeId = new Map();\n    PrebindingManager.variableMappingByPatternId = new Map();\n    PrebindingManager.newToOriginalNodeIdMap = new Map();\n    PrebindingManager.paramIdToOverwriteIdMap = new Map();\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/src/core/preview/PrebindingManager.d.ts

@@ -1,152 +0,0 @@
-import { ExperienceComponentSettings, ParameterDefinition } from '@contentful/experiences-core/types';
-export type ParameterDefinitionWithParameterId = {
-    parameterId: string;
-    parameter: ParameterDefinition;
-};
-/**
- * PrebindingManager utility class for resolving parameter bindings across nested patterns.
- *
- * The core approach is to first resolve the top-level parameterId using `getParameterIdByNodeId`,
- * which uses the paramIdToOverwriteIdMap, set when storing pre-binding based on the passToNodes chain to determine which parameter in the parent pattern
- * overrides a given parameterId (with some additionally workaround due to node ID renaming for patterns).
- * Once the owning top-level `parameterId` is found, we can follow the `passToNodes` chain back
- * down to retrieve all nested overrides — including parameter definitions, allowed content types,
- * and default sources — up to three levels deep.
- *
- * ## Lifecycle
- * This utility class currently uses static state, with Zustand stores supplementing the “latest” data
- * for root-level patterns data — for example, when overwriting content types on nested patterns or binding
- * fields on simple patterns. If we need the override mappings to be reactive, we could easily move
- * the full override chain tracking into Zustand but currently we can rely on the pattern definition
- * stores we have currently.
- *
- * The state is populated during deserialization, where we call `storePrebindingDefinitions` for each
- * pattern node. It is ready to be consumed at each level as nodes are deserialized top-down:
- * 1. Pattern C (Template Pattern)
- * 2. Pattern B (Nested Pattern)
- * 3. Pattern A (Simple Pattern)
- *
- * At each level, accessing overrides is possible:
- * - Pattern C has everything it needs once deserialized with its own parameters
- * - Pattern B has everything it needs once deserialized, with its own parameters possibly overridden by C
- * - Pattern A has its own parameters and possiblle overrites by B and/or C
- *
- * After actions that modify patterns without re-deserializing the tree — such as duplication,
- * deletion, or detachment — this state must be kept up to date via storePrebindingDefinitions
- * or storeParameterDefinitions if only parameter definitions are updated.
- *
- * ## Core Data Structures
- *
- *  - prebindingDefinitions           - A collection of all prebinding definitions aggregated
- *                                       from the parent pattern down to all nested patterns.
- *
- *  - prebindingDefinitionIdsByNodeId - Same as above, but indexed by `nodeId`. This allows us
- *                                       to easily find the prebinding definition id for a given node ID.
- *
- *  - parameterDefinitionsById        - A collection of all parameter definitions aggregated
- *                                       from the parent pattern down to nested patterns.
- *
- *  - variableMappingByPatternId      - A collection of all variable mappings aggregated from
- *                                       the parent pattern down to nested patterns, indexed by
- *                                       `patternId` for efficient access.
- *
- *  - newToOriginalNodeIdMap          - When deserializing pattern child nodes, we replace their
- *                                       node IDs with new ones based on their location inside the
- *                                       pattern. This prevents conflicts when multiple instances
- *                                       of the same pattern exist. The issue is that prebinding
- *                                       `passToNodes` resolution requires the original node ID.
- *                                       This map allows us to retrieve it to follow the chain.
- *
- *  - paramIdToOverwriteIdMap         - Tracks parameter ID overrides through the `passToNodes`
- *                                       chain, allowing us to resolve overrides correctly from
- *                                       the top-level parameter down to the lowest-level.
- */
-export declare class PrebindingManager {
-    private static prebindingDefinitions;
-    private static prebindingDefinitionIdsByNodeId;
-    private static parameterDefinitionsById;
-    private static parameterDefinitionsByNodeId;
-    private static variableMappingByPatternId;
-    private static newToOriginalNodeIdMap;
-    private static paramIdToOverwriteIdMap;
-    /**
-     * Links new node IDs to original node IDs
-     * - This is used to track the original node IDs for pattern instances as we change them when deserializing pattern nodes.
-     * @param newNodeId
-     * @param originalNodeId
-     */
-    static linkOriginalNodeIds(newNodeId: string, originalNodeId: string): void;
-    /**
-     * Initializes the pattern editor manager by storing the definitions during deserialization
-     * for the root pattern and all nested patterns.
-     *
-     * @param nodeId - The ID of the pattern node.
-     * @param patternEntryId - The ID of the pattern entry from the patterns store.
-     * @param prebindingDefinitions - The prebinding definitions from the current pattern's component settings.
-     */
-    static storePrebindingDefinitions(nodeId: string, patternEntryId: string, prebindingDefinitions: NonNullable<ExperienceComponentSettings['prebindingDefinitions']>): void;
-    /**
-     * Stores parameter definitions for a given nodeId.
-     * @param nodeId - The ID of the node to store parameter definitions for.
-     * @param parameterDefinitions - The parameter definitions to store.
-     */
-    static storeParameterDefinitions(nodeId: string, parameterDefinitions?: Record<string, ParameterDefinition>): void;
-    /**
-     * Resolves the top-level parameterId for a given nodeId.
-     *
-     * @param nodeId - The nodeId to resolve the parameterId for
-     * @param useStoreParameters - Whether to use the zustand store parameters or not
-     * @returns string | undefined - The resolved parameterId or undefined if not found
-     **/
-    static getParameterIdByNodeId(nodeId: string): string | undefined;
-    static getParameterDefinitionsByParameterId(parameterId: string): (ParameterDefinitionWithParameterId | undefined)[] | undefined;
-    /**
-     * Returns all parameter definitions defined on the pattern of the given nodeId OR the pattern, wrapping the given nodeId
-     */
-    static getAllParameterDefinitionsForNodeId(nodeId: string): {
-        [k: string]: {
-            contentTypes: string[];
-            passToNodes: {
-                prebindingId: string;
-                parameterId: string;
-                nodeId: string;
-            }[];
-            defaultSource?: {
-                type: "Entry";
-                contentTypeId: string;
-                link: {
-                    sys: {
-                        type: "Link";
-                        id: string;
-                        linkType: "Entry";
-                    };
-                };
-            } | undefined;
-        };
-    };
-    /**
-     * Return all parameter ID's on a pattern by NodeId
-     * @param nodeId - The nodeId to return params for
-     * @returns string[] An array of parameter IDs or undefined
-     */
-    static getAllParameterIdsByNodeId(nodeId: string): string[] | undefined;
-    /**
-     * Get the highest level overriding parameterId for a given parameterId + nodeId combination
-     * @param parameterId - The parameter to resolve
-     * @param indexedNodeId - The indexed node ID to resolve the parameterId for
-     * @returns string - The resolved parameterId - will be from "root" in patterns or the parent pattern node in experiences
-     */
-    static getHoistedIdForParameterId(parameterId: string, indexedNodeId: string): string;
-    /**
-     * Retrieves the native parameter definition for a given nodeId. ie one without passToNodes on the node.
-     * @param nodeId - The nodeId to retrieve the native parameter definition for
-     * @returns The native parameter definition for the given nodeId, or undefined if not found
-     */
-    static getNativeParameterDefinitionByNodeId(nodeId: string): ParameterDefinitionWithParameterId | undefined;
-    private static extractNativeParameterDefinition;
-    /**
-     * Resets all properties of the PrebindingManager class
-     * triggered when we leave ExperienceBuilder back to experience folder view.
-     **/
-    static reset(): void;
-}

package/dist/src/core/preview/PrebindingManager.test.d.ts

@@ -1 +0,0 @@
-export {};