@infosel-sdk/widgets

SDK de Widgets para la plataforma Infosel. Proporciona herramientas completas para crear, gestionar y configurar widgets, espacios de trabajo e instrumentos para aplicaciones financieras.

🚀 Características

• Gestión de Widgets: Crear, actualizar, eliminar y duplicar widgets financieros personalizables
• Gestión de Espacios de Trabajo: Organizar y gestionar espacios de trabajo de usuarios
• Gestión de Instrumentos: Crear y gestionar instrumentos financieros personalizados
• Configuración Avanzada: Soporte para múltiples tipos de widgets (gráficos, tablas, noticias, etc.)
• API GraphQL: Comunicación eficiente mediante GraphQL

📦 Instalación

npm install @infosel-sdk/widgets

🚀 Inicio Rápido

✨ Configuración Moderna (Recomendado)

La nueva API del core proporciona una configuración más limpia y validada:

import InfoselWidgets from '@infosel-sdk/widgets';
import { InfoselSdkManager, AuthConfigurationBuilder } from '@infosel-sdk/core';

// Configuración moderna con Builder Pattern
const authConfig = AuthConfigurationBuilder.keyCloak()
  .withRealm('hub')
  .withEnvironment('qa')
  .withCredentials({
    grant_type: 'client_credentials',
    client_id: 'tu-client-id',
    client_secret: 'tu-client-secret',
  })
  .build();

// Inicializar SDK Manager con configuración moderna
const sdkManager = InfoselSdkManager.initWithConfiguration({
  authConfiguration: authConfig,
});

// Inicializar SDK de Widgets
const widgetsSDK = InfoselWidgets.init({ sdkManager });

// Crear un espacio de trabajo
const workspace = await widgetsSDK.createWorkspace({
  name: 'Mi Dashboard',
  description: 'Espacio de trabajo personal',
});

Configuración con Token Existente

import InfoselWidgets from '@infosel-sdk/widgets';
import {
  InfoselSdkManager,
  AuthConfigurationBuilder,
  Token,
} from '@infosel-sdk/core';

// Configuración con token existente
const token: Token = {
  accessToken: 'tu-access-token',
  refreshToken: 'tu-refresh-token',
};

const authConfig = AuthConfigurationBuilder.existingToken()
  .withRealm('hub')
  .withEnvironment('prod')
  .withClientId('hub-app')
  .withToken(token)
  .build();

const sdkManager = InfoselSdkManager.initWithConfiguration({
  authConfiguration: authConfig,
});

const widgetsSDK = InfoselWidgets.init({ sdkManager });

🔍 Validación de Configuración

La nueva API incluye validaciones robustas:

import { AuthConfigurationBuilder } from '@infosel-sdk/core';

const builder = AuthConfigurationBuilder.keyCloak()
  .withRealm('invalid@realm') // Caracteres inválidos
  .withCredentials({
    grant_type: 'client_credentials',
    client_id: '', // Client ID vacío
    client_secret: 'secret',
  });

// Validar antes de construir
const validation = builder.validate();
if (!validation.isValid) {
  console.log('Errores:', validation.errors);
  // ['Realm contains invalid characters...', 'Client ID is required...']
}

// O validar automáticamente al construir
try {
  const config = builder.build();
} catch (error) {
  console.error(error.message); // Lista todos los errores de validación
}

📚 API Completa del SDK

🏢 Gestión de Espacios de Trabajo

Crear Espacio de Trabajo

const workspace = await widgetsSDK.createWorkspace({
  name: 'Mi Dashboard de Trading',
  description: 'Espacio de trabajo personal para análisis de mercado',
  userId: 'user-123', // Opcional: asociar a usuario específico
  projectId: 'project-123', // Opcional: asociar a proyecto específico
});

console.log('Espacio de trabajo creado:', workspace);

Obtener Espacios de Trabajo

// Obtener todos los espacios de trabajo de un proyecto
const allWorkspaces = await widgetsSDK.getWorkspaces({
  projectId: 'project-123',
});

// Obtener espacios de trabajo por usuario
const userWorkspaces = await widgetsSDK.getWorkspacesByUser({
  userId: 'user-123',
});

// Obtener espacios de trabajo específicos del usuario (por connectionId)
const specificUserWorkspaces = await widgetsSDK.getUserWorkspaces({
  connectionId: 'connection-123',
  projectId: 'project-123',
});

// Obtener espacios de trabajo por ID de proyecto
const projectWorkspaces = await widgetsSDK.getWorkspacesByProjectId({
  projectId: 'project-123',
});

console.log('Espacios de trabajo:', allWorkspaces);

Obtener Detalles del Espacio de Trabajo

const workspaceDetails = await widgetsSDK.getWorkspace({
  workspaceId: 'workspace-123',
});

console.log('Detalles del workspace:', workspaceDetails);
console.log('Widgets en el workspace:', workspaceDetails.widgets);

Actualizar Espacio de Trabajo

const updatedWorkspace = await widgetsSDK.updateWorkspace({
  id: 'workspace-123',
  name: 'Dashboard Actualizado',
  description: 'Nueva descripción del espacio de trabajo',
});

console.log('Espacio de trabajo actualizado:', updatedWorkspace);

Duplicar Espacio de Trabajo

const duplicatedWorkspace = await widgetsSDK.duplicateWorkspace({
  id: 'workspace-123',
  name: 'Copia de Mi Dashboard',
});

console.log('Espacio de trabajo duplicado:', duplicatedWorkspace);

Eliminar Espacio de Trabajo

const result = await widgetsSDK.deleteWorkspace({
  id: 'workspace-123',
});

console.log('Resultado:', result); // ID del workspace eliminado

🎯 Gestión de Widgets

Crear Widget

// Widget de gráfico
const chartWidget = await widgetsSDK.createWidget({
  workspaceId: 'workspace-123',
  type: 'CHART',
  name: 'Gráfico de AAPL',
  instruments: [
    {
      uniqueKey: 'AAPL_US',
      symbol: 'AAPL',
    },
  ],
});

// Widget de tabla dinámica
const tableWidget = await widgetsSDK.createWidget({
  workspaceId: 'workspace-123',
  type: 'DYNAMIC_TABLE',
  name: 'Tabla de Precios',
  instruments: [
    {
      uniqueKey: 'AAPL_US',
      symbol: 'AAPL',
    },
    {
      uniqueKey: 'MSFT_US',
      symbol: 'MSFT',
    },
  ],
});

// Widget de lista de noticias
const newsWidget = await widgetsSDK.createWidget({
  workspaceId: 'workspace-123',
  type: 'NEWS_LIST',
  name: 'Noticias Financieras',
  newsConfiguration: {
    period: 12,
    listType: 9,
    limit: 20,
    offset: 0,
    sourcesId: '',
    newsTypeId: '',
  },
  sizes: {
    create: {
      node: {
        width: 12,
        height: 18,
        minWidth: 12,
        minHeight: 12,
        maxWidth: 18,
        maxHeight: 18,
        x: 0,
        y: 0,
      },
    },
  },
});

console.log('Widget creado:', chartWidget);

Tipos de Widgets Disponibles

// Tipos soportados:
// - 'FINANCIAL_STATEMENTS': Estados financieros
// - 'DYNAMIC_TABLE': Tabla dinámica
// - 'PREDEFINED_TABLE': Tabla predefinida
// - 'NEWS_LIST': Lista de noticias
// - 'TICKER_TAPE': Cinta de ticker
// - 'CHART': Gráfico
// - 'CUSTOM_TABLE': Tabla personalizada
// - 'SHORT_SALES': Ventas en corto
// - 'MARKET_TOTAL': Total de mercado
// - 'TRADED_PACKAGES': Paquetes negociados
// - 'BROKERAGE_TRADES': Operaciones de corretaje
// - 'BROKERAGE_CONCENTRATION': Concentración de corretaje
// - 'BROKERAGE_PARTICIPATION': Participación de corretaje
// - 'DECREED_RIGHTS_SEARCHER': Buscador de derechos decretados
// - 'INDICES_COMPONENTS': Componentes de índices

Actualizar Instrumentos del Widget

const updatedInstruments = await widgetsSDK.updateWidgetInstruments({
  widgetId: 'widget-123',
  instruments: {
    keys: ['AAPL_US', 'MSFT_US', 'GOOGL_US'],
  },
});

console.log('Instrumentos actualizados:', updatedInstruments);

Actualizar Configuración del Gráfico del Widget

const result = await widgetsSDK.updateWidgetChart({
  widgetId: 'widget-123',
  chartConfiguration: {
    id: 'chart-config-123',
    globalConfiguration: JSON.stringify({
      // Configuración del gráfico
      type: 'line',
      colors: ['#FF5733', '#33FF57'],
    }),
  },
});

console.log('Configuración actualizada:', result);

Duplicar Widget

const duplicatedWidget = await widgetsSDK.duplicateWidget({
  widgetId: 'widget-123',
  workspaceId: 'workspace-456',
  name: 'Copia del Widget',
});

console.log('Widget duplicado:', duplicatedWidget);

Eliminar Widget

const result = await widgetsSDK.deleteWidget('widget-123');
console.log('Resultado:', result); // ID del widget eliminado

Obtener Widgets del Proyecto

const projectWidgets = await widgetsSDK.getProjectWidgets({
  projectId: 'project-123',
});

console.log('Widgets del proyecto:', projectWidgets);
console.log('Widgets por workspace:', projectWidgets.workspaces);

Obtener Widgets del Usuario

const userWidgets = await widgetsSDK.getUserWidgets({
  id: 'user-123',
});

console.log('Widgets del usuario:', userWidgets);
console.log('Total de widgets:', userWidgets.widgets.length);

🔧 Gestión de Instrumentos

Crear Instrumento Personalizado

const newInstrument = await widgetsSDK.createInstrument({
  symbol: 'CUSTOM_STOCK',
  uniqueKey: 'CUSTOM_001',
  widgetId: 'widget-123',
});

console.log('Instrumento creado:', newInstrument);

Obtener Lista de Instrumentos

const instruments = await widgetsSDK.getInstruments({
  workspaceId: 'workspace-123',
  // Parámetros opcionales de paginación
  limit: 50,
  offset: 0,
});

console.log('Total de instrumentos:', instruments.total);
console.log('Instrumentos:', instruments.fields);

Eliminar Instrumento

const result = await widgetsSDK.deleteInstrument('instrument-id-123');
console.log('Resultado:', result); // ID del instrumento eliminado

🔧 Ejemplos Prácticos Completos

📱 Dashboard Completo de Widgets

import InfoselWidgets from '@infosel-sdk/widgets';
import { InfoselSdkManager, AuthConfigurationBuilder } from '@infosel-sdk/core';

class WidgetsDashboard {
  private widgetsSDK: InfoselWidgets;

  constructor() {
    this.initializeSDK();
  }

  private async initializeSDK() {
    const authConfig = AuthConfigurationBuilder.keyCloak()
      .withRealm('hub')
      .withEnvironment('qa')
      .withCredentials({
        grant_type: 'client_credentials',
        client_id: process.env.KEYCLOAK_CLIENT_ID!,
        client_secret: process.env.KEYCLOAK_CLIENT_SECRET!,
      })
      .build();

    const sdkManager = InfoselSdkManager.initWithConfiguration({
      authConfiguration: authConfig,
    });

    this.widgetsSDK = InfoselWidgets.init({ sdkManager });
  }

  // Crear dashboard completo
  async createCompleteDashboard(userId: string, projectId: string) {
    try {
      // 1. Crear espacio de trabajo
      const workspace = await this.widgetsSDK.createWorkspace({
        name: 'Dashboard de Trading',
        description: 'Dashboard completo para análisis de mercado',
        userId,
        projectId,
      });

      // 2. Crear widget de gráfico para AAPL
      const chartWidget = await this.widgetsSDK.createWidget({
        workspaceId: workspace.id,
        type: 'CHART',
        name: 'Gráfico AAPL',
        instruments: [{ uniqueKey: 'AAPL_US', symbol: 'AAPL' }],
      });

      // 3. Crear widget de tabla para múltiples instrumentos
      const tableWidget = await this.widgetsSDK.createWidget({
        workspaceId: workspace.id,
        type: 'DYNAMIC_TABLE',
        name: 'Portafolio',
        instruments: [
          { uniqueKey: 'AAPL_US', symbol: 'AAPL' },
          { uniqueKey: 'MSFT_US', symbol: 'MSFT' },
          { uniqueKey: 'GOOGL_US', symbol: 'GOOGL' },
        ],
      });

      // 4. Crear widget de noticias
      const newsWidget = await this.widgetsSDK.createWidget({
        workspaceId: workspace.id,
        type: 'NEWS_LIST',
        name: 'Noticias Financieras',
        newsConfiguration: {
          period: 12,
          listType: 9,
          limit: 20,
          offset: 0,
          sourcesId: '',
          newsTypeId: '',
        },
      });

      return {
        workspace,
        widgets: [chartWidget, tableWidget, newsWidget],
      };
    } catch (error) {
      console.error('Error creando dashboard:', error);
      throw error;
    }
  }

  // Duplicar workspace completo
  async duplicateWorkspaceWithWidgets(workspaceId: string, newName: string) {
    try {
      // 1. Obtener workspace original
      const originalWorkspace = await this.widgetsSDK.getWorkspace({
        workspaceId,
      });

      // 2. Duplicar workspace
      const duplicatedWorkspace = await this.widgetsSDK.duplicateWorkspace({
        id: workspaceId,
        name: newName,
      });

      return duplicatedWorkspace;
    } catch (error) {
      console.error('Error duplicando workspace:', error);
      throw error;
    }
  }
}

// Uso del dashboard
async function main() {
  const dashboard = new WidgetsDashboard();

  try {
    // Crear dashboard completo
    const result = await dashboard.createCompleteDashboard(
      'user-123',
      'project-123',
    );
    console.log('Dashboard creado:', result);

    // Duplicar workspace
    const duplicated = await dashboard.duplicateWorkspaceWithWidgets(
      result.workspace.id,
      'Copia del Dashboard',
    );
    console.log('Workspace duplicado:', duplicated);
  } catch (error) {
    console.error('Error en main:', error);
  }
}

main();

🎯 Gestor de Widgets Avanzado

class AdvancedWidgetManager {
  private widgetsSDK: InfoselWidgets;

  constructor(widgetsSDK: InfoselWidgets) {
    this.widgetsSDK = widgetsSDK;
  }

  // Crear widget de gráfico con configuración
  async createChartWidget(
    workspaceId: string,
    instrument: string,
    name: string,
  ) {
    try {
      const widget = await this.widgetsSDK.createWidget({
        workspaceId,
        type: 'CHART',
        name,
        instruments: [{ uniqueKey: instrument, symbol: instrument }],
        sizes: {
          create: {
            node: {
              width: 800,
              height: 600,
              minWidth: 400,
              minHeight: 300,
              maxWidth: 1200,
              maxHeight: 900,
              x: 0,
              y: 0,
            },
          },
        },
      });

      return widget;
    } catch (error) {
      console.error('Error creando widget de gráfico:', error);
      throw error;
    }
  }

  // Crear widget de tabla con múltiples instrumentos
  async createTableWidget(
    workspaceId: string,
    instruments: string[],
    name: string,
  ) {
    try {
      const widget = await this.widgetsSDK.createWidget({
        workspaceId,
        type: 'DYNAMIC_TABLE',
        name,
        instruments: instruments.map(instrument => ({
          uniqueKey: instrument,
          symbol: instrument,
        })),
      });

      return widget;
    } catch (error) {
      console.error('Error creando widget de tabla:', error);
      throw error;
    }
  }

  // Actualizar instrumentos de un widget
  async updateWidgetInstruments(widgetId: string, instruments: string[]) {
    try {
      const updatedInstruments = await this.widgetsSDK.updateWidgetInstruments({
        widgetId,
        instruments: { keys: instruments },
      });

      return updatedInstruments;
    } catch (error) {
      console.error('Error actualizando instrumentos:', error);
      throw error;
    }
  }

  // Duplicar widget a otro workspace
  async duplicateWidgetToWorkspace(
    widgetId: string,
    targetWorkspaceId: string,
    newName?: string,
  ) {
    try {
      const duplicatedWidget = await this.widgetsSDK.duplicateWidget({
        widgetId,
        workspaceId: targetWorkspaceId,
        name: newName || `Copia de Widget ${widgetId}`,
      });

      return duplicatedWidget;
    } catch (error) {
      console.error('Error duplicando widget:', error);
      throw error;
    }
  }

  // Eliminar widget
  async deleteWidget(widgetId: string) {
    try {
      const result = await this.widgetsSDK.deleteWidget(widgetId);
      return result;
    } catch (error) {
      console.error('Error eliminando widget:', error);
      throw error;
    }
  }
}

// Uso del gestor de widgets
const widgetManager = new AdvancedWidgetManager(widgetsSDK);

// Crear widgets en un workspace
async function setupWorkspaceWidgets(workspaceId: string) {
  try {
    // Widget de gráfico para AAPL
    const chartWidget = await widgetManager.createChartWidget(
      workspaceId,
      'AAPL_US',
      'Gráfico de Apple',
    );

    // Widget de tabla para portafolio
    const tableWidget = await widgetManager.createTableWidget(
      workspaceId,
      ['AAPL_US', 'MSFT_US', 'GOOGL_US'],
      'Portafolio Principal',
    );

    console.log('Widgets creados:', { chartWidget, tableWidget });
    return { chartWidget, tableWidget };
  } catch (error) {
    console.error('Error configurando widgets:', error);
    throw error;
  }
}

🏢 Gestor de Espacios de Trabajo

class WorkspaceManager {
  private widgetsSDK: InfoselWidgets;

  constructor(widgetsSDK: InfoselWidgets) {
    this.widgetsSDK = widgetsSDK;
  }

  // Crear workspace con widgets iniciales
  async createWorkspaceWithWidgets(
    name: string,
    description: string,
    userId: string,
    projectId: string,
    initialInstruments: string[] = [],
  ) {
    try {
      // 1. Crear workspace
      const workspace = await this.widgetsSDK.createWorkspace({
        name,
        description,
        userId,
        projectId,
      });

      // 2. Crear widgets iniciales si hay instrumentos
      const widgets = [];
      if (initialInstruments.length > 0) {
        const chartWidget = await this.widgetsSDK.createWidget({
          workspaceId: workspace.id,
          type: 'CHART',
          name: 'Gráfico Principal',
          instruments: initialInstruments.map(instrument => ({
            uniqueKey: instrument,
            symbol: instrument,
          })),
        });
        widgets.push(chartWidget);
      }

      return { workspace, widgets };
    } catch (error) {
      console.error('Error creando workspace con widgets:', error);
      throw error;
    }
  }

  // Obtener todos los workspaces de un usuario
  async getUserWorkspaces(userId: string) {
    try {
      const workspaces = await this.widgetsSDK.getWorkspacesByUser({
        userId,
      });

      return workspaces;
    } catch (error) {
      console.error('Error obteniendo workspaces del usuario:', error);
      throw error;
    }
  }

  // Actualizar workspace
  async updateWorkspace(
    workspaceId: string,
    updates: { name?: string; description?: string },
  ) {
    try {
      const updatedWorkspace = await this.widgetsSDK.updateWorkspace({
        id: workspaceId,
        ...updates,
      });

      return updatedWorkspace;
    } catch (error) {
      console.error('Error actualizando workspace:', error);
      throw error;
    }
  }

  // Duplicar workspace completo
  async duplicateWorkspace(workspaceId: string, newName: string) {
    try {
      const duplicatedWorkspace = await this.widgetsSDK.duplicateWorkspace({
        id: workspaceId,
        name: newName,
      });

      return duplicatedWorkspace;
    } catch (error) {
      console.error('Error duplicando workspace:', error);
      throw error;
    }
  }

  // Eliminar workspace
  async deleteWorkspace(workspaceId: string) {
    try {
      const result = await this.widgetsSDK.deleteWorkspace({
        id: workspaceId,
      });

      return result;
    } catch (error) {
      console.error('Error eliminando workspace:', error);
      throw error;
    }
  }
}

// Uso del gestor de workspaces
const workspaceManager = new WorkspaceManager(widgetsSDK);

// Crear workspace con widgets iniciales
async function createUserDashboard(userId: string, projectId: string) {
  try {
    const result = await workspaceManager.createWorkspaceWithWidgets(
      'Mi Dashboard Personal',
      'Dashboard para análisis de mercado',
      userId,
      projectId,
      ['AAPL_US', 'MSFT_US', 'GOOGL_US'],
    );

    console.log('Dashboard creado:', result);
    return result;
  } catch (error) {
    console.error('Error creando dashboard:', error);
    throw error;
  }
}

📚 Referencia de API

Clases Principales

InfoselWidgets

Punto de entrada principal para el SDK de Widgets. Se inicializa usando el método estático init() que recibe el InfoselSdkManager.

InfoselSdkManager

Gestor central del SDK que maneja la configuración, autenticación y modo de operación. Se inicializa usando el método estático initWithConfiguration() con configuración moderna o init() con configuración legacy.

AuthConfigurationBuilder

Builder para crear configuraciones de autenticación validadas y centralizadas. Proporciona una API fluida para configurar autenticación KeyCloak y basada en tokens.

WidgetsMapper

Mapeador de datos para convertir entre modelos de API y dominio.

Métodos Disponibles

🏢 Gestión de Espacios de Trabajo

| Método | Descripción | Parámetros | | ---------------------------- | --------------------------------------------------- | ---------------------------- | | createWorkspace() | Crear nuevo espacio de trabajo | CreateWorkspaceRequest | | getWorkspaces() | Obtener espacios de trabajo de un proyecto | GetWorkspacesRequest | | getWorkspacesByUser() | Obtener espacios de trabajo del usuario | GetWorkspacesByUserRequest | | getUserWorkspaces() | Obtener espacios de trabajo específicos del usuario | GetUserWorkspacesRequest | | getWorkspacesByProjectId() | Obtener espacios de trabajo por ID de proyecto | GetWorkspacesRequest | | getWorkspace() | Obtener detalles del workspace | GetWorkspaceRequest | | updateWorkspace() | Actualizar espacio de trabajo | UpdateWorkspaceRequest | | duplicateWorkspace() | Duplicar espacio de trabajo | DuplicateWorkspaceRequest | | deleteWorkspace() | Eliminar espacio de trabajo | DeleteWorkspaceRequest |

🎯 Gestión de Widgets

| Método | Descripción | Parámetros | | --------------------------- | ------------------------------------ | -------------------------------- | | createWidget() | Crear nuevo widget | CreateWidgetRequest | | duplicateWidget() | Duplicar widget | DuplicateWidgetRequest | | updateWidgetInstruments() | Actualizar instrumentos del widget | UpdateWidgetInstrumentsRequest | | updateWidgetChart() | Actualizar configuración del gráfico | UpdateWidgetChartRequest | | deleteWidget() | Eliminar widget | string (ID) | | getProjectWidgets() | Obtener widgets del proyecto | GetProjectWidgetsRequest | | getUserWidgets() | Obtener widgets del usuario | GetUserWidgetsRequest |

🔧 Gestión de Instrumentos

| Método | Descripción | Parámetros | | -------------------- | ----------------------------- | ------------------------- | | createInstrument() | Crear nuevo instrumento | CreateInstrumentRequest | | deleteInstrument() | Eliminar instrumento | string (ID) | | getInstruments() | Obtener lista de instrumentos | GetInstrumentsRequest |

Entidades

Entidades Principales

• Widget: Configuración y datos del widget
• Workspace: Espacio de trabajo del usuario
• Instrument: Representación de instrumento financiero
• WorkspaceWidgets: Workspace con sus widgets asociados
• UserWidgets: Widgets del usuario
• UserWorkspaces: Espacios de trabajo del usuario
• ProjectWidgetsContainer: Contenedor de widgets del proyecto
• WorkspacesContainer: Contenedor de espacios de trabajo
• InstrumentsResponse: Respuesta con lista de instrumentos

Entidades de Solicitud/Respuesta

• CreateWidgetRequest: Parámetros de creación de widget
• CreateWorkspaceRequest: Parámetros de creación de espacio de trabajo
• CreateInstrumentRequest: Parámetros de creación de instrumento
• UpdateWidgetInstrumentsRequest: Parámetros de actualización de instrumentos
• UpdateWidgetChartRequest: Parámetros de actualización de gráfico
• UpdateWorkspaceRequest: Parámetros de actualización de workspace
• DuplicateWidgetRequest: Parámetros de duplicación de widget
• DuplicateWorkspaceRequest: Parámetros de duplicación de workspace
• DeleteWorkspaceRequest: Parámetros de eliminación de workspace
• GetWorkspaceRequest: Parámetros para obtener workspace
• GetWorkspacesRequest: Parámetros para obtener workspaces
• GetWorkspacesByUserRequest: Parámetros para obtener workspaces por usuario
• GetUserWorkspacesRequest: Parámetros para obtener workspaces del usuario
• GetUserWidgetsRequest: Parámetros para obtener widgets del usuario
• GetProjectWidgetsRequest: Parámetros para obtener widgets del proyecto
• GetInstrumentsRequest: Parámetros para obtener instrumentos

Tipos de Widgets

• FINANCIAL_STATEMENTS: Estados financieros
• DYNAMIC_TABLE: Tabla dinámica con datos en tiempo real
• PREDEFINED_TABLE: Tabla predefinida con estructura fija
• CUSTOM_TABLE: Tabla personalizable
• NEWS_LIST: Lista de noticias financieras
• TICKER_TAPE: Cinta de ticker con precios
• CHART: Gráfico de precios y volúmenes
• SHORT_SALES: Ventas en corto
• MARKET_TOTAL: Total de mercado
• TRADED_PACKAGES: Paquetes negociados
• BROKERAGE_TRADES: Operaciones de corretaje
• BROKERAGE_CONCENTRATION: Concentración de corretaje
• BROKERAGE_PARTICIPATION: Participación de corretaje
• DECREED_RIGHTS_SEARCHER: Buscador de derechos decretados
• INDICES_COMPONENTS: Componentes de índices

🔗 Dependencias

• @infosel-sdk/core: Funcionalidad core del SDK (versión ^0.0.5)
• dayjs: Manejo de fechas y horas
• tslib: Biblioteca runtime de TypeScript

🆕 Novedades en Core v0.0.5

✨ Configuration Builder Pattern

• Nueva API fluida para configuración sin duplicaciones
• Validaciones centralizadas con mensajes de error descriptivos
• Single source of truth para configuración de realm
• Compatibilidad hacia atrás mantenida

🔧 Mejoras en Configuración

• Configuración dinámica de realm para múltiples ambientes
• Validación de formatos de realm, client_id y credenciales
• Valores por defecto inteligentes basados en el tipo de autenticación
• Type safety mejorado con TypeScript

🧪 Testing

Pruebas Unitarias

# Ejecutar tests unitarios
npm test

# Ejecutar tests con cobertura
npm run test:coverage

📞 Soporte

Para soporte y preguntas, por favor contacta al equipo de desarrollo de Infosel.

🔗 Paquetes Relacionados

• @infosel-sdk/core: Funcionalidad core del SDK (versión ^0.0.5)
• @infosel-sdk/markets: SDK de mercados financieros
• @infosel-sdk/news: SDK de noticias y contenido
• @infosel-sdk/securities: SDK de valores y trading