@maestro_io/maestro-web-sdk 2.1.1 → 2.1.3

package/dist/external/AxiosNetworkClient.js

@@ -0,0 +1,83 @@
+import axios from 'axios';
+const REQUEST_TIMEOUT = 5000;
+class AxiosNetworkClient {
+    constructor({ baseURL, retries, delay, backoff, axiosInstance, }) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "delay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "backoff", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.retries = retries;
+        this.delay = delay;
+        this.backoff = backoff;
+        this.client =
+            axiosInstance ||
+                axios.create({
+                    baseURL,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    timeout: REQUEST_TIMEOUT,
+                });
+    }
+    async retry(operation, attempt = 0) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const axiosError = error;
+            // Check if we should retry
+            const shouldRetry = attempt < this.retries &&
+                ((axiosError.response && axiosError.response.status === 429) ||
+                    axiosError.code === 'ECONNABORTED');
+            if (shouldRetry) {
+                const delayTime = this.delay * Math.pow(this.backoff, attempt);
+                console.log(`Retrying request in ${delayTime}ms due to: ${axiosError.message}`);
+                await new Promise((resolve) => setTimeout(resolve, delayTime));
+                return this.retry(operation, attempt + 1);
+            }
+            throw error;
+        }
+    }
+    async get(endpoint, params, headers) {
+        return this.retry(async () => {
+            const response = await this.client.get(endpoint, {
+                params,
+                headers,
+            });
+            return response.data;
+        });
+    }
+    async post(endpoint, data) {
+        return this.retry(async () => {
+            const response = await this.client.post(endpoint, data);
+            return response.data;
+        });
+    }
+    setAuthentication(token, apiKey) {
+        this.client.defaults.headers.common['Authorization'] = token
+            ? `Bearer ${token}`
+            : '';
+        this.client.defaults.headers.common['x-maestro-api-key'] = apiKey || '';
+    }
+}
+export default AxiosNetworkClient;

package/dist/external/LocalStorageCacheManager.js

@@ -0,0 +1,213 @@
+/**
+ * Manages caching using localStorage with support for TTL, size limits, and versioning.
+ * This class implements the ICacheManager interface and provides methods for setting, getting,
+ * and clearing cache entries.
+ */
+export default class LocalStorageCacheManager {
+    /**
+     * Creates a new LocalStorageCacheManager instance.
+     * @param cacheDuration - The time-to-live (TTL) for cache entries in milliseconds.
+     * @param maxSize - The maximum size of the cache in bytes.
+     * @param version - The version of the cache. Used to invalidate cache entries when the version changes.
+     */
+    constructor(cacheDuration = 3600000, maxSize = 5 * 1024 * 1024, version = '1.0') {
+        Object.defineProperty(this, "prefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'maestro-cache-'
+        });
+        Object.defineProperty(this, "cacheDuration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "accessLog", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cacheDuration = cacheDuration;
+        this.maxSize = maxSize;
+        this.version = version;
+        this.accessLog = new Map();
+    }
+    /**
+     * Produces a cache key by combining the prefix, version, and the provided key.
+     * @param key - The key to be used in the cache.
+     * @returns The generated cache key.
+     */
+    produceCacheKey(key) {
+        return `${this.prefix}${this.version}:${key}`;
+    }
+    /**
+     * Calculates the current size of the cache in bytes.
+     * @returns The total size of the cache in bytes.
+     */
+    getCurrentSize() {
+        let totalSize = 0;
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.startsWith(this.prefix)) {
+                const value = localStorage.getItem(key);
+                if (value) {
+                    totalSize += key.length + value.length;
+                }
+            }
+        }
+        return totalSize;
+    }
+    /**
+     * Cleans up old cache entries based on their TTL.
+     */
+    cleanupOldEntries() {
+        const now = Date.now();
+        // Collect keys to remove first
+        const keysToRemove = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.startsWith(this.prefix)) {
+                const value = localStorage.getItem(key);
+                if (value) {
+                    try {
+                        const { timestamp } = JSON.parse(value);
+                        if (now - timestamp > this.cacheDuration) {
+                            keysToRemove.push(key);
+                        }
+                    }
+                    catch (err) {
+                        keysToRemove.push(key);
+                    }
+                }
+            }
+        }
+        keysToRemove.forEach((key) => {
+            localStorage.removeItem(key);
+            // Remove from accessLog
+            const logicalKey = key.replace(this.prefix + this.version + ':', '');
+            this.accessLog.delete(logicalKey);
+        });
+    }
+    /**
+     * Cleans up least recently used cache entries when the cache is full.
+     */
+    cleanupLRUEntries(newItemSize) {
+        // Remove oldest entries until we're under the size limit
+        const entries = Array.from(this.accessLog.entries()).sort(([, a], [, b]) => a - b);
+        while (this.getCurrentSize() + newItemSize > this.maxSize &&
+            entries.length > 0) {
+            const [key] = entries.shift();
+            localStorage.removeItem(this.produceCacheKey(key));
+            this.accessLog.delete(key);
+        }
+    }
+    /**
+     * Sets a value in the cache with the specified key.
+     * @param key - The key to store the value under.
+     * @param data - The value to be stored in the cache.
+     */
+    setCache(key, data) {
+        this.cleanupOldEntries();
+        const cacheKey = this.produceCacheKey(key);
+        const cacheData = {
+            data,
+            timestamp: Date.now(),
+        };
+        const newItemSize = cacheKey.length + JSON.stringify(cacheData).length;
+        this.cleanupLRUEntries(newItemSize);
+        // After cleanup, check if it fits
+        if (this.getCurrentSize() + newItemSize > this.maxSize) {
+            // Still doesn't fit, don't add
+            return;
+        }
+        localStorage.setItem(cacheKey, JSON.stringify(cacheData));
+        this.accessLog.set(key, Date.now());
+    }
+    /**
+     * Retrieves a value from the cache by its key.
+     * @param key - The key to retrieve the value for.
+     * @returns The cached value, or null if the key is not found or the entry has expired.
+     */
+    getCache(key) {
+        this.cleanupOldEntries();
+        const cacheKey = this.produceCacheKey(key);
+        const cachedData = localStorage.getItem(cacheKey);
+        if (!cachedData) {
+            return null;
+        }
+        try {
+            const { data, timestamp } = JSON.parse(cachedData);
+            const now = Date.now();
+            if (now - timestamp > this.cacheDuration) {
+                localStorage.removeItem(cacheKey);
+                this.accessLog.delete(key);
+                return null;
+            }
+            // Update last access time
+            this.accessLog.set(key, now);
+            return data;
+        }
+        catch (err) {
+            localStorage.removeItem(cacheKey);
+            this.accessLog.delete(key);
+            return null;
+        }
+    }
+    /**
+     * Clears a specific cache entry by its key.
+     * @param key - The key of the cache entry to clear.
+     */
+    clearCache(key) {
+        const cacheKey = this.produceCacheKey(key);
+        localStorage.removeItem(cacheKey);
+        this.accessLog.delete(key);
+    }
+    /**
+     * Clears all cache entries that match the specified pattern.
+     * @param pattern - The pattern to match against cache keys.
+     */
+    clearCacheByPattern(pattern) {
+        // Collect all matching keys first
+        const keysToRemove = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.startsWith(this.prefix) && key.includes(pattern)) {
+                keysToRemove.push(key);
+            }
+        }
+        keysToRemove.forEach((key) => {
+            localStorage.removeItem(key);
+            // Remove from accessLog
+            const logicalKey = key.replace(this.prefix + this.version + ':', '');
+            this.accessLog.delete(logicalKey);
+        });
+    }
+    /**
+     * Clears all cache entries.
+     */
+    clearAllCache() {
+        const keysToRemove = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.startsWith(this.prefix)) {
+                keysToRemove.push(key);
+            }
+        }
+        keysToRemove.forEach((key) => localStorage.removeItem(key));
+        this.accessLog.clear();
+    }
+}

package/dist/external/ReactRenderer.d.ts

@@ -1,6 +1,6 @@
-import { type IRenderer } from './ports/renderer';
+import { IRenderer } from './ports/renderer';
 import { MaestroViewModels } from '@/view-models';
-import type IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
+import IMaestroEventDelegate from '@/interfaces/IMaestroEventDelegate';
 declare class ReactRenderer implements IRenderer {
     private renderersMap;
     viewModels: MaestroViewModels | null;

package/dist/external/ReactRenderer.js

@@ -0,0 +1,86 @@
+import { MaestroViewModels } from '@/view-models';
+import React from 'react';
+import ReactDOM from 'react-dom';
+import OverlayContainer from '../components/core/OverlayContainer';
+class ReactRenderer {
+    constructor() {
+        Object.defineProperty(this, "renderersMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "viewModels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * Sets the view models for the renderer
+     * @param eventId The event ID to create view models for
+     * @param delegate The event delegate to use
+     */
+    async setViewModels(eventId, delegate) {
+        try {
+            if (!delegate) {
+                console.error('No event delegate provided');
+                return null;
+            }
+            this.viewModels = await MaestroViewModels.fromEventId(eventId, delegate);
+            return this.viewModels;
+        }
+        catch (error) {
+            console.error('Error creating view models from event ID', error);
+            return null;
+        }
+    }
+    /**
+     * Renders the panel manager
+     * @param id The element ID to render in
+     * @param options Options for rendering including height and width
+     */
+    async renderPanel(id) {
+        const renderer = await this.getRenderer(id);
+        if (!this.viewModels) {
+            throw new Error('Cannot render panel manager: No view models set');
+        }
+        const App = require('../components/core/App').default;
+        const PanelManager = require('../components/core/PanelManager').default;
+        renderer.render(React.createElement(App, null,
+            React.createElement(PanelManager, null),
+            React.createElement(OverlayContainer, {
+                viewModels: this.viewModels,
+            })));
+        return () => {
+            renderer.unmount();
+            this.renderersMap.delete(id);
+        };
+    }
+    /**
+     * @description Get the render function and renderer for the MaestroWebSDK. Useful to configure the renderer and fonts before rendering the component.
+     * @param {string} id - The id of the element to render the component in.
+     * @param {{ height: number; width: number }} options - The height and width of the component.
+     */
+    async getRenderer(id) {
+        if (this.renderersMap.has(id)) {
+            return this.renderersMap.get(id);
+        }
+        const el = document.getElementById(id);
+        if (!el) {
+            throw new Error(`Element with id ${id} not found`);
+        }
+        const renderer = {
+            render: (children) => {
+                ReactDOM.render(children, el);
+            },
+            unmount: () => {
+                ReactDOM.unmountComponentAtNode(el);
+            },
+        };
+        this.renderersMap.set(id, renderer);
+        return renderer;
+    }
+}
+export default ReactRenderer;

package/dist/external/mocks/MockExternalNetworkClient.js

@@ -0,0 +1,161 @@
+/**
+ * A mock implementation of the INetworkClient interface for testing
+ * and development purposes.
+ */
+class MockNetworkClient {
+    /**
+     * Constructor for MockNetworkClient
+     *
+     * @param mockResponses - Optional initial mock responses mapping
+     * @param mockErrors - Optional initial mock errors mapping
+     * @param defaultResponse - Default response for unmocked endpoints
+     * @param delay - Simulated network delay in milliseconds
+     */
+    constructor({ mockResponses = {}, mockErrors = {}, defaultResponse = { success: true }, delay = 0, } = {}) {
+        Object.defineProperty(this, "mockResponses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "mockErrors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "defaultResponse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { success: true }
+        });
+        Object.defineProperty(this, "defaultError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "latestRequest", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "delay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        // Convert object to Map
+        Object.entries(mockResponses).forEach(([key, value]) => {
+            this.mockResponses.set(key, value);
+        });
+        Object.entries(mockErrors).forEach(([key, value]) => {
+            this.mockErrors.set(key, value);
+        });
+        this.defaultResponse = defaultResponse;
+        this.delay = delay;
+    }
+    /**
+     * Get the latest request made to this mock client
+     */
+    getLatestRequest() {
+        return this.latestRequest;
+    }
+    /**
+     * Set a mock response for a specific endpoint
+     *
+     * @param endpoint - The API endpoint
+     * @param response - The mock response data
+     */
+    setMockResponse(endpoint, response) {
+        this.mockResponses.set(endpoint, response);
+    }
+    /**
+     * Set a mock error for a specific endpoint
+     *
+     * @param endpoint - The API endpoint
+     * @param error - The error to throw
+     */
+    setMockError(endpoint, error) {
+        this.mockErrors.set(endpoint, error);
+    }
+    /**
+     * Set a default mock response for all unmocked endpoints
+     *
+     * @param response - The default response data
+     */
+    setDefaultResponse(response) {
+        this.defaultResponse = response;
+    }
+    /**
+     * Set a default error for all endpoints not configured with specific errors
+     *
+     * @param error - The default error
+     */
+    setDefaultError(error) {
+        this.defaultError = error;
+    }
+    /**
+     * Set the simulated network delay
+     *
+     * @param delayMs - Delay in milliseconds
+     */
+    setDelay(delayMs) {
+        this.delay = delayMs;
+    }
+    /**
+     * Clear all mock responses and errors
+     */
+    reset() {
+        this.mockResponses.clear();
+        this.mockErrors.clear();
+        this.defaultResponse = { success: true };
+        this.defaultError = null;
+        this.latestRequest = null;
+    }
+    /**
+     * Helper method to handle the common response/error/delay logic
+     */
+    async handleRequest(method, endpoint, data, params, headers) {
+        this.latestRequest = { method, endpoint, data, params, headers };
+        // Apply delay if configured
+        if (this.delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.delay));
+        }
+        // Check if there's a specific error for this endpoint
+        if (this.mockErrors.has(endpoint)) {
+            throw this.mockErrors.get(endpoint);
+        }
+        // Check if there's a default error
+        if (this.defaultError) {
+            throw this.defaultError;
+        }
+        // Return mock response for the endpoint, or the default response
+        return this.mockResponses.has(endpoint)
+            ? this.mockResponses.get(endpoint)
+            : this.defaultResponse;
+    }
+    /**
+     * Mock implementation of the get method
+     */
+    async get(endpoint, params, headers) {
+        return this.handleRequest('GET', endpoint, undefined, params, headers);
+    }
+    /**
+     * Mock implementation of the post method
+     */
+    async post(endpoint, data) {
+        return this.handleRequest('POST', endpoint, data);
+    }
+    /**
+     * Mock implementation of setAuthentication
+     */
+    setAuthentication(token, apiKey) {
+        // No-op in mock implementation
+        console.log('setAuthentication called with token:', token, 'and apiKey:', apiKey);
+    }
+}
+export default MockNetworkClient;

package/dist/external/ports/cacheManager.js

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

package/dist/external/ports/networkClient.js

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

package/dist/external/ports/renderer.js

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

package/dist/external/spatial-navigation/index.d.ts

@@ -1,5 +1,4 @@
 import withFocusable, { WithFocusableProps } from './withFocusable';
-import { InitOptions, KeyMap } from './spatialNavigation';
-declare const destroy: () => void, pause: () => void, resume: () => void, setFocus: (targetFocusKey: string, details?: Record<string, any>) => void, init: ({ debug, visualDebug, nativeMode, throttle, throttleKeypresses, }?: InitOptions) => void, setKeyMap: (keyMap: KeyMap) => void;
-export { withFocusable, init, setKeyMap, destroy, pause, resume, setFocus };
-export type { InitOptions, KeyMap, WithFocusableProps };
+import SpatialNavigation, { InitOptions, KeyMap } from './spatialNavigation';
+export { withFocusable, SpatialNavigation };
+export { InitOptions, KeyMap, WithFocusableProps };

package/dist/external/spatial-navigation/index.js

@@ -0,0 +1,3 @@
+import withFocusable from './withFocusable';
+import SpatialNavigation from './spatialNavigation';
+export { withFocusable, SpatialNavigation };

package/dist/external/spatial-navigation/measureLayout.js

@@ -0,0 +1,30 @@
+const ELEMENT_NODE = 1;
+const getRect = (node) => {
+    let { offsetParent } = node;
+    const height = node.offsetHeight;
+    const width = node.offsetWidth;
+    let left = node.offsetLeft;
+    let top = node.offsetTop;
+    while (offsetParent && offsetParent.nodeType === ELEMENT_NODE) {
+        left += offsetParent.offsetLeft - offsetParent.scrollLeft;
+        top += offsetParent.offsetTop - offsetParent.scrollTop;
+        ({ offsetParent } = offsetParent);
+    }
+    return {
+        height,
+        left,
+        top,
+        width,
+    };
+};
+const measureLayout = (node, callback) => {
+    const relativeNode = node && node.parentNode;
+    if (relativeNode) {
+        const relativeRect = getRect(relativeNode);
+        const { height, left, top, width } = getRect(node);
+        const x = left - relativeRect.left;
+        const y = top - relativeRect.top;
+        callback(x, y, width, height, left, top);
+    }
+};
+export default measureLayout;

package/dist/external/spatial-navigation/spatialNavigation.d.ts

@@ -72,7 +72,6 @@ declare class SpatialNavigation {
     private focusableComponents;
     private focusKey;
     private parentsHavingFocusedChild;
-    private enabled;
     private nativeMode;
     private throttle;
     private throttleKeypresses;
@@ -105,7 +104,7 @@ declare class SpatialNavigation {
      * They used as a base to measure adjacent slices
      */
     sortSiblingsByPriority(siblings: FocusableComponent[], currentLayout: Layout, direction: Direction, _focusKey: string): FocusableComponent[];
-    constructor();
+    constructor(options?: InitOptions);
     init({ debug, visualDebug, nativeMode, throttle, throttleKeypresses, }?: InitOptions): void;
     startDrawLayouts(): void;
     destroy(): void;
@@ -153,5 +152,4 @@ declare class SpatialNavigation {
 /**
  * Export singleton
  */
-declare const _default: SpatialNavigation;
-export default _default;
+export default SpatialNavigation;