@myop/sdk 0.2.3 → 0.2.5

package/dist/bundled-declarations.d.ts

@@ -1436,220 +1436,48 @@ declare module "@myop/sdk/helpers/configBuilder" {
     }
 }
 declare module "@myop/sdk/helpers/CloudRepository" {
-    import { IUserFlow } from "@myop/sdk/common";
+    import { IUserFlow, v2_IVariantConfig } from "@myop/sdk/common";
     /**
+     * CloudRepository - Unified cloud data access layer for Myop components
      *
-     * ## Overview
-     *
-     * The `CloudRepository` class serves as a centralized data access layer for retrieving user flows and components from the Myop.dev cloud service. It implements a singleton pattern and provides caching mechanisms to optimize API calls and improve performance.
-     *
-     * ## Class Structure
-     *
-     * ### Constructor
-     *
-     * ```typescript
-     * constructor(private _baseUrl = 'https://cloud.myop.dev')
-     * ```
-     *
-     * **Parameters:**
-     * - `_baseUrl` (optional): The base URL for the Myop.dev cloud API. Defaults to `'https://cloud.myop.dev'`
-     *
-     * ### Static Properties
-     *
-     * #### Main
-     * ```typescript
-     * static Main = new CloudRepository();
-     * ```
-     *
-     * A singleton instance of the `CloudRepository` class that can be used throughout the application without creating multiple instances.
-     *
-     * ### Private Properties
-     *
-     * #### userFlows
-     * ```typescript
-     * private userFlows: Record<string, Promise<IUserFlow>> = {};
-     * ```
-     *
-     * A cache object that stores promises for user flows, indexed by flow ID. This prevents duplicate API calls for the same flow and ensures consistent data retrieval.
-     *
-     * #### _baseUrl
-     * ```typescript
-     * private _baseUrl: string
-     * ```
-     *
-     * The base URL for the cloud API endpoints, set during construction.
-     *
-     * ## Methods
-     *
-     * ### fetchFlow(flowId: string)
-     *
-     * Retrieves a complete user flow from the cloud repository, including all resolved components.
-     *
-     * **Parameters:**
-     * - `flowId`: The unique identifier for the user flow to retrieve
-     *
-     * **Returns:**
-     * - `Promise<IUserFlow>`: A promise that resolves to the complete user flow object
-     *
-     * **Behavior:**
-     * - Implements request caching to avoid duplicate API calls for the same flow ID
-     * - Makes a GET request to `/flow?id={flowId}&resolve=components`
-     * - Automatically resolves component references within the flow
-     * - Stores the promise in the cache for future use
-     *
-     * **Example Usage:**
-     * ```typescript
-     * const flow = await CloudRepository.Main.fetchFlow('my-flow-id');
-     * console.log(flow.components);
-     * ```
-     *
-     * ### fetchComponent(componentId: string, flowId: string)
-     *
-     * Retrieves a specific component from within a user flow.
-     *
-     * **Parameters:**
-     * - `componentId`: The unique identifier for the component to retrieve
-     * - `flowId`: The unique identifier for the user flow containing the component
-     *
-     * **Returns:**
-     * - `Promise<Component | undefined>`: A promise that resolves to the component object if found, or undefined if not found
-     *
-     * **Behavior:**
-     * - First fetches the complete flow using `fetchFlow()`
-     * - Searches through the flow's components array to find the matching component
-     * - Uses the component's `type.id` property for matching
-     *
-     * **Example Usage:**
-     * ```typescript
-     * const component = await CloudRepository.Main.fetchComponent('button-component', 'my-flow-id');
-     * if (component) {
-     *     console.log('Component found:', component);
-     * } else {
-     *     console.log('Component not found in flow');
-     * }
-     * ```
-     *
-     * ## API Integration
-     *
-     * ### Endpoint Structure
-     *
-     * The class integrates with the following Myop.dev cloud API endpoint:
-     *
-     * ```
-     * GET {baseUrl}/flow?id={flowId}&resolve=components
-     * ```
-     *
-     * **Query Parameters:**
-     * - `id`: The flow identifier
-     * - `resolve=components`: Instructs the API to include resolved component data in the response
-     *
-     * ### Response Format
-     *
-     * The API is expected to return a JSON response with the following structure:
-     *
-     * ```json
-     * {
-     *     "item": {
-     *         // IUserFlow object with resolved components
-     *         "components": [
-     *             {
-     *                 "type": {
-     *                     "id": "component-id"
-     *                 }
-     *                 // ... other component properties
-     *             }
-     *         ]
-     *         // ... other flow properties
-     *     }
-     * }
-     * ```
-     *
-     * ## Caching Strategy
-     *
-     * The `CloudRepository` implements a promise-based caching mechanism:
-     *
-     * 1. **Cache Key**: Flow ID is used as the cache key
-     * 2. **Cache Value**: Promises are cached rather than resolved values to handle concurrent requests
-     * 3. **Cache Duration**: Cache persists for the lifetime of the repository instance
-     * 4. **Cache Invalidation**: No automatic cache invalidation is implemented
-     *
-     * ## Error Handling
-     *
-     * - Network errors and API failures are propagated through promise rejection
-     * - No specific error handling or retry logic is implemented at the repository level
-     * - Consumers should implement appropriate error handling when calling repository methods
-     *
-     * ## Usage Patterns
-     *
-     * ### Singleton Access
-     * ```typescript
-     * import { CloudRepository } from './path/to/CloudRepository';
-     *
-     * // Use the singleton instance
-     * const flow = await CloudRepository.Main.fetchFlow('flow-id');
-     * ```
-     *
-     * ### Custom Instance
-     * ```typescript
-     * // Create a custom instance with different base URL
-     * const customRepo = new CloudRepository('https://custom-api.example.com');
-     * const flow = await customRepo.fetchFlow('flow-id');
-     * ```
-     *
-     * ### Component Retrieval
-     * ```typescript
-     * // Get a specific component from a flow
-     * const component = await CloudRepository.Main.fetchComponent('component-id', 'flow-id');
-     * ```
-     *
-     * ## Dependencies
-     *
-     * - **IUserFlow**: Interface imported from `../common` that defines the structure of user flow objects
-     * - **Fetch API**: Uses the native `fetch` function for HTTP requests
-     *
-     * ## Performance Considerations
-     *
-     * - **Caching**: Prevents duplicate API calls for the same flow ID
-     * - **Promise Caching**: Handles concurrent requests efficiently by caching promises
-     * - **Component Resolution**: The `resolve=components` parameter ensures components are fully resolved in a single API call
-     *
-     * ## Future Enhancements
-     *
-     * The class structure suggests planned functionality that could be implemented:
-     *
-     * - **Component Caching**: The commented `components` property indicates potential individual component caching
-     * - **Cache Invalidation**: Methods to clear or refresh cached data
-     * - **Error Retry Logic**: Automatic retry mechanisms for failed requests
-     * - **Batch Operations**: Methods to fetch multiple flows or components in a single request
-     *
+     * Supports both v2 (default) and v1 modes:
+     * - v2: Uses /consume endpoint for fetching variants
+     * - v1: Uses /flow endpoint for fetching user flows
      */
     export class CloudRepository {
         private _baseUrl;
         static Main: CloudRepository;
+        private variants;
         private userFlows;
         constructor(_baseUrl?: string);
-        fetchComponent(componentId: string, flowId?: string): Promise<import("common").IComponentConfig>;
+        /**
+         * Check if a component is already cached/preloaded (v2)
+         */
+        isPreloaded(componentId: string): boolean;
+        /**
+         * Fetch a v2 component variant
+         */
+        fetchComponentV2(componentId: string, environmentIdentifier?: string): Promise<v2_IVariantConfig>;
+        /**
+         * Fetch a v1 component from a flow
+         */
+        fetchComponentV1(componentId: string, flowId?: string): Promise<import("common").IComponentConfig>;
         fetchAutoFlow(componentId: string): Promise<IUserFlow>;
         fetchFlow(flowId: string): Promise<IUserFlow>;
+        /**
+         * @deprecated Use fetchComponentV2 or fetchComponentV1 explicitly
+         * Defaults to v1 behavior for backward compatibility with existing code
+         */
+        fetchComponent(componentId: string, flowId?: string): Promise<import("common").IComponentConfig>;
     }
+    /**
+     * @deprecated Use CloudRepository instead
+     */
+    export const v2_CloudRepository: typeof CloudRepository;
 }
 declare module "@myop/sdk/helpers/exec" {
     export const exec: (getter: any) => Promise<any>;
 }
-declare module "@myop/sdk/helpers/enableV2" {
-    import { v2_IVariantConfig } from "@myop/sdk/common";
-    import { loaderOptions } from "@myop/sdk/host/hostSDK";
-    export class v2_CloudRepository {
-        private _baseUrl;
-        static Main: v2_CloudRepository;
-        private variants;
-        constructor(_baseUrl?: string);
-        fetchComponent(componentId: string, environmentIdentifier?: string): Promise<v2_IVariantConfig>;
-    }
-    export const enableV2: (environmentIdentifier: string, cloudRepository?: v2_CloudRepository) => {
-        loadComponent: (componentId: string, container: HTMLElement, options?: loaderOptions) => Promise<import("host").IMyopComponent<any, any>>;
-    };
-}
 declare module "@myop/sdk/helpers" {
     export * from "@myop/sdk/helpers/applyStylesheet";
     export * from "@myop/sdk/helpers/iframeSkinUrlTokenizer";
@@ -1657,7 +1485,6 @@ declare module "@myop/sdk/helpers" {
     export * from "@myop/sdk/helpers/configBuilder";
     export * from "@myop/sdk/helpers/CloudRepository";
     export * from "@myop/sdk/helpers/exec";
-    export * from "@myop/sdk/helpers/enableV2";
 }
 declare module "@myop/sdk/host/myopOverride" {
     import { IComponentConfig } from "@myop/sdk/common";

package/dist/cjs/{_IframeSDK.c7f71dba.js → _IframeSDK.69b595c4.js}

@@ -1731,7 +1731,7 @@ var WebcomponentLoader = class extends BaseMyopLoader {
 };
 
 // version:myop-sdk-version
-var myop_sdk_version_default = "0.2.3";
+var myop_sdk_version_default = "0.2.5";
 
 // src/webcomponent/messageHandlers/BaseWebComponentMessageHandler.ts
 var BaseWebComponentMessageHandler = class extends BaseContextMessageHandler {
@@ -2171,12 +2171,46 @@ var HTMLComponentLoader = class extends BaseMyopLoader {
 
 // src/helpers/CloudRepository.ts
 var _CloudRepository = class _CloudRepository {
-  // private components: Record<string, Promise<IUserFlow>> = {};
   constructor(_baseUrl = "https://cloud.myop.dev") {
     this._baseUrl = _baseUrl;
+    // v2 cache
+    __publicField(this, "variants", {});
+    // v1 cache
     __publicField(this, "userFlows", {});
   }
-  async fetchComponent(componentId, flowId) {
+  // ============ V2 Methods (Default) ============
+  /**
+   * Check if a component is already cached/preloaded (v2)
+   */
+  isPreloaded(componentId) {
+    return componentId in this.variants;
+  }
+  /**
+   * Fetch a v2 component variant
+   */
+  async fetchComponentV2(componentId, environmentIdentifier) {
+    if (!this.variants[componentId]) {
+      this.variants[componentId] = new Promise(
+        async (resolve, reject) => {
+          try {
+            const res = await fetch(
+              "".concat(this._baseUrl, "/consume?id=").concat(componentId, "&env=").concat(environmentIdentifier)
+            );
+            const json = await res.json();
+            resolve(json.item);
+          } catch (e) {
+            reject(e);
+          }
+        }
+      );
+    }
+    return await this.variants[componentId];
+  }
+  // ============ V1 Methods (Legacy) ============
+  /**
+   * Fetch a v1 component from a flow
+   */
+  async fetchComponentV1(componentId, flowId) {
     if (flowId) {
       const flow = await this.fetchFlow(flowId);
       return flow.components.find((c) => c.type.id === componentId);
@@ -2221,38 +2255,18 @@ var _CloudRepository = class _CloudRepository {
     }
     return await this.userFlows[flowId];
   }
+  // ============ Backward Compatibility ============
+  /**
+   * @deprecated Use fetchComponentV2 or fetchComponentV1 explicitly
+   * Defaults to v1 behavior for backward compatibility with existing code
+   */
+  async fetchComponent(componentId, flowId) {
+    return this.fetchComponentV1(componentId, flowId);
+  }
 };
 __publicField(_CloudRepository, "Main", new _CloudRepository());
 var CloudRepository = _CloudRepository;
 
-// src/helpers/enableV2.ts
-var _v2_CloudRepository = class _v2_CloudRepository {
-  constructor(_baseUrl = "https://cloud.myop.dev") {
-    this._baseUrl = _baseUrl;
-    __publicField(this, "variants", {});
-  }
-  async fetchComponent(componentId, environmentIdentifier) {
-    if (!this.variants[componentId]) {
-      this.variants[componentId] = new Promise(
-        async (resolve, reject) => {
-          try {
-            const res = await fetch(
-              "".concat(this._baseUrl, "/consume?id=").concat(componentId, "&env=").concat(environmentIdentifier)
-            );
-            const json = await res.json();
-            resolve(json.item);
-          } catch (e) {
-            reject(e);
-          }
-        }
-      );
-    }
-    return await this.variants[componentId];
-  }
-};
-__publicField(_v2_CloudRepository, "Main", new _v2_CloudRepository());
-var v2_CloudRepository = _v2_CloudRepository;
-
 // src/host/myopOverride.ts
 var checkMyopOverride = async (componentConfig) => {
   try {