@viasoftbr/shared-ui 0.0.1 → 0.0.2

package/dist/services/api.d.ts

@@ -0,0 +1,23 @@
+import { ProtocolSettings } from '../types/protocol';
+export declare const api: import("axios").AxiosInstance;
+export declare const authApi: import("axios").AxiosInstance;
+export declare function getAccessToken(): string | null;
+export declare function setAccessToken(token: string | null): void;
+export declare function getRefreshToken(): string | null;
+export declare function setRefreshToken(token: string | null): void;
+export declare function clearTokens(): void;
+export declare const fetchApi: {
+    getJson: <T>(path: string, params?: Record<string, any>, headers?: Record<string, string>) => Promise<T>;
+    getText: (path: string, params?: Record<string, any>, headers?: Record<string, string>) => Promise<string>;
+    getVoid: (path: string, params?: Record<string, any>, headers?: Record<string, string>) => Promise<void>;
+    postJson: <T>(path: string, payload?: any, headers?: Record<string, string>) => Promise<T>;
+    patchJson: <T>(path: string, payload?: any, headers?: Record<string, string>) => Promise<T>;
+    putJson: <T>(path: string, payload?: any, headers?: Record<string, string>) => Promise<T>;
+    deleteJson: <T>(path: string, headers?: Record<string, string>) => Promise<T>;
+    deleteVoid: (path: string, headers?: Record<string, string>) => Promise<void>;
+};
+export declare const serverOrigin: string;
+export declare function buildWsUrl(path?: string): string;
+export declare function encodeFfurl(settings: ProtocolSettings): Promise<string>;
+export declare function decodeFfurl(ffurl: string): Promise<ProtocolSettings>;
+export declare function subscribeToWebsocket(url: string, onMessage: (data: any) => void): () => void;

package/dist/services/auth.d.ts

@@ -0,0 +1,15 @@
+import { User } from '../types';
+interface LoginResponse {
+    accessToken: string;
+    refreshToken: string;
+    user: User;
+}
+export declare const authService: {
+    login: (username: string, password: string) => Promise<LoginResponse>;
+    refresh: () => Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    logout: () => Promise<void>;
+};
+export {};

package/dist/services/discovery.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Discovery helpers for service availability.
+ * Calls the backend endpoint that lists available subservices.
+ */
+export declare const discoveryService: {
+    /**
+     * GET /services/available (authenticated)
+     * Returns whatever the backend provides about available services/subservices.
+     */
+    available: () => Promise<any>;
+};
+export default discoveryService;

package/dist/services/hostConfig.d.ts

@@ -0,0 +1,20 @@
+export interface HostStaticRoute {
+    path: string;
+    pageId?: string;
+    public?: boolean;
+    level?: string;
+}
+export interface HostConfig {
+    version?: string;
+    pluginsManifestUrl?: string;
+    defaultRoute?: string;
+    staticRoutes?: HostStaticRoute[];
+    features?: Record<string, any>;
+}
+declare class HostConfigLoader {
+    private cache?;
+    loadHostConfig(url?: string): Promise<HostConfig>;
+    clearCache(): void;
+}
+export declare const hostConfigLoader: HostConfigLoader;
+export {};

package/dist/services/index.d.ts

@@ -0,0 +1,9 @@
+export * from './api';
+export * from './auth';
+export * from './loadRemoteModule';
+export * from './metadataLoader';
+export * from './registry';
+export * from './hostConfig';
+export * from './users';
+export * from './wizard';
+export * from './discovery';

package/dist/services/loadRemoteModule.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentType } from 'react';
+declare global {
+    var __federation_shared__: Record<string, Record<string, unknown>>;
+}
+export declare function loadRemoteModule(config: {
+    scope: string;
+    url: string;
+    module: string;
+}): Promise<ComponentType>;

package/dist/services/metadataLoader.d.ts

@@ -0,0 +1,9 @@
+import type { PageMetadata } from "../types/plugin.types";
+export declare class MetadataLoader {
+    private metadataCache;
+    loadMetadata(metadataUrl: string): Promise<PageMetadata[]>;
+    loadFromDirectory(directoryUrl: string): Promise<PageMetadata[]>;
+    clearCache(): void;
+    getCachedMetadata(metadataUrl: string): PageMetadata[] | undefined;
+}
+export declare const metadataLoader: MetadataLoader;

package/dist/services/registry.d.ts

@@ -0,0 +1,42 @@
+import type React from 'react';
+export type RouteLevel = 'readonly' | 'operator' | 'admin' | 'public';
+export interface RouteConfig {
+    path: string;
+    componentName?: string;
+    pageId?: string;
+    title?: string;
+    level?: RouteLevel;
+}
+export interface PageConfig {
+    id: string;
+    name: string;
+    path: string;
+    component: React.ComponentType<any>;
+    icon?: React.ComponentType<any> | React.ReactNode;
+}
+export interface PluginRegistry {
+    registerComponent(name: string, component: React.ComponentType): void;
+    getComponent(name: string): React.ComponentType | undefined;
+    registerService<T = any>(name: string, service: T): void;
+    getService<T = any>(name: string): T | undefined;
+    registerRoute(route: RouteConfig): void;
+    getRoutes(): RouteConfig[];
+    registerPage(page: PageConfig): void;
+    getPages(): PageConfig[];
+}
+declare class PluginRegistryImpl implements PluginRegistry {
+    private components;
+    private services;
+    private routes;
+    private pages;
+    registerComponent(name: string, component: React.ComponentType): void;
+    getComponent(name: string): React.ComponentType<{}> | undefined;
+    registerService<T = any>(name: string, service: T): void;
+    getService<T = any>(name: string): T | undefined;
+    registerRoute(route: RouteConfig): void;
+    getRoutes(): RouteConfig[];
+    registerPage(page: PageConfig): void;
+    getPages(): PageConfig[];
+}
+export declare const registry: PluginRegistryImpl;
+export {};

package/dist/services/users.d.ts

@@ -0,0 +1,18 @@
+import { Role, User } from '../types';
+export declare const userService: {
+    list: () => Promise<User[]>;
+    getById: (id: string) => Promise<User>;
+    create: (payload: {
+        name?: string;
+        username: string;
+        password: string;
+        role?: Role;
+    }) => Promise<User>;
+    update: (id: string, payload: Partial<{
+        name: string;
+        username: string;
+        password: string;
+        role: Role;
+    }>) => Promise<User>;
+    delete: (id: string) => Promise<void>;
+};

package/dist/services/wizard.d.ts

@@ -0,0 +1,3 @@
+export declare const getDeviceInfo: (basePath?: string) => Promise<any>;
+export declare const saveConfig: (payload: any, basePath?: string) => Promise<any>;
+export declare const isFirstRun: (basePath?: string) => Promise<boolean>;

package/dist/services.js

@@ -2640,19 +2640,36 @@ var {
 } = axios_default;
 
 // src/services/api.ts
-var getApiBaseUrl = () => {
-  if (typeof import.meta !== "undefined" && import.meta.env?.VITE_API_BASE_URL) {
-    return import.meta.env.VITE_API_BASE_URL;
+var normalizeOrigin = (raw) => {
+  if (!raw)
+    return "";
+  if (/^https?:\/\//i.test(raw) || /^wss?:\/\//i.test(raw))
+    return raw.replace(/\/$/, "");
+  return `http://${raw.replace(/\/$/, "")}`;
+};
+var getApiOrigin = () => {
+  try {
+    if (typeof import.meta !== "undefined" && import.meta.env?.VITE_API_BASE_URL) {
+      return normalizeOrigin(import.meta.env.VITE_API_BASE_URL);
+    }
+  } catch (e) {
   }
-  return "192.168.100.9:3000";
+  if (typeof window !== "undefined") {
+    const win = window;
+    if (win.__VIASOFT_API_BASE_URL)
+      return normalizeOrigin(win.__VIASOFT_API_BASE_URL);
+    if (window.location && window.location.origin)
+      return window.location.origin.replace(/\/$/, "");
+  }
+  return "http://localhost:3000";
 };
-var serverUrl = getApiBaseUrl();
+var apiOrigin = getApiOrigin();
 var api = axios_default.create({
-  baseURL: `http://${serverUrl}`,
+  baseURL: apiOrigin,
   timeout: 1e4
 });
 var authApi = axios_default.create({
-  baseURL: `http://${serverUrl}`,
+  baseURL: apiOrigin,
   timeout: 1e4
 });
 function getAccessToken() {
@@ -2816,7 +2833,7 @@ var fetchApi = {
     }
   }
 };
-var serverOrigin = `http://${serverUrl}`;
+var serverOrigin = apiOrigin;
 function buildWsUrl(path = "/") {
   try {
     const origin2 = new URL(serverOrigin);
@@ -2826,8 +2843,9 @@ function buildWsUrl(path = "/") {
     origin2.pathname = path;
     return origin2.toString();
   } catch (e) {
-    const proto = serverOrigin.startsWith("https") ? "wss" : "ws";
-    return `${proto}://${serverUrl}${path.startsWith("/") ? path : "/" + path}`;
+    const proto = apiOrigin.startsWith("https") ? "wss" : "ws";
+    const host = apiOrigin.replace(/^https?:\/\//, "").replace(/\/$/, "");
+    return `${proto}://${host}${path.startsWith("/") ? path : "/" + path}`;
   }
 }
 async function encodeFfurl(settings) {
@@ -2893,7 +2911,6 @@ var authService = {
 // src/services/loadRemoteModule.ts
 import * as React from "react";
 import * as ReactDOM from "react-dom";
-var loadedContainers = /* @__PURE__ */ new Map();
 var sharedScopeInitialized = false;
 function getSharedScope() {
   if (!globalThis.__federation_shared__) {
@@ -2920,28 +2937,46 @@ function getSharedScope() {
   }
   return globalThis.__federation_shared__;
 }
+var loadedContainers = /* @__PURE__ */ new Map();
+var initializedContainers = /* @__PURE__ */ new Set();
 async function loadContainer(url) {
   if (loadedContainers.has(url)) {
-    const cached = loadedContainers.get(url);
-    if (cached)
-      return cached;
+    return loadedContainers.get(url);
   }
-  const promise = import(
-    /* @vite-ignore */
-    url
-  );
-  loadedContainers.set(url, promise);
-  return promise;
+  const loadPromise = (async () => {
+    try {
+      const container = await import(
+        /* @vite-ignore */
+        url
+      );
+      if (container.init && !initializedContainers.has(url)) {
+        await container.init(getSharedScope());
+        initializedContainers.add(url);
+      }
+      return container;
+    } catch (error) {
+      loadedContainers.delete(url);
+      initializedContainers.delete(url);
+      throw error;
+    }
+  })();
+  loadedContainers.set(url, loadPromise);
+  return loadPromise;
 }
 async function loadRemoteModule(config) {
   const container = await loadContainer(config.url);
-  if (!container || typeof container.init !== "function") {
-    throw new Error(`Container inv\xE1lido: ${config.scope}`);
+  if (!container || typeof container.get !== "function") {
+    throw new Error(`Container inv\xE1lido ou sem m\xE9todo get: ${config.scope}`);
+  }
+  if (typeof container.dynamicLoadingCss === "function") {
+    try {
+      await container.dynamicLoadingCss([]);
+    } catch (err) {
+      console.warn(`Aviso: Falha ao carregar CSS global do remote ${config.scope}`, err);
+    }
   }
-  const shareScope = getSharedScope();
-  container.init(shareScope);
   const factory2 = await container.get(config.module);
-  const moduleExports = factory2();
+  const moduleExports = await factory2();
   if (moduleExports && typeof moduleExports === "object" && "default" in moduleExports) {
     return moduleExports.default;
   }
@@ -2975,7 +3010,7 @@ var MetadataLoader = class {
         );
       }
       metadata.forEach((page, index) => {
-        if (!page.id || !page.name || !page.path || !page.bundleUrl) {
+        if (!page.id || !page.name || !page.path || !page.url) {
           throw new Error(
             `Invalid page metadata at index ${index}: missing required fields`
           );

package/dist/types/alarm.d.ts

@@ -0,0 +1,21 @@
+export type AlarmType = "critical" | "warning";
+export interface Alarm {
+    status: AlarmType;
+    code: string;
+    details: string;
+    alias: string;
+    enabled: boolean;
+}
+export interface GetAlarmsResponse {
+    alarms: Alarm[];
+}
+export type AlarmAction = "activate" | "deactivate";
+export interface ManageAlarmRequest {
+    code: string;
+    action: AlarmAction;
+}
+export interface ManageAlarmResponse {
+    message: string;
+    code: string;
+    action: AlarmAction;
+}

package/dist/types/auth.d.ts

@@ -0,0 +1,18 @@
+export declare enum Role {
+    Admin = "admin",
+    Operator = "operator",
+    SuperAdmin = "superadmin",
+    ReadOnly = "readonly"
+}
+export interface JwtPayload {
+    sub: string;
+    exp: number;
+    iat: number;
+    roles: Role[];
+}
+export interface User {
+    id: string;
+    username: string;
+    role: Role;
+    name?: string;
+}

package/dist/types/group.d.ts

@@ -0,0 +1,32 @@
+interface GroupProps {
+    expanded: boolean;
+    onToggle: (section: string) => void;
+    available?: string[];
+    children?: React.ReactNode;
+    title?: string;
+    loading?: boolean;
+}
+interface AudioProps {
+    audioSource: 'SDI' | 'USB';
+    audioCodec: 'aac' | 'he_aac' | 'he_aac_v2';
+    audioBitrate: string;
+    audioSampleRate: "24kHz" | "48kHz" | "96kHz" | "192kHz";
+    audioChannels: "stero" | "monol" | "monor";
+}
+interface FilterProps {
+    inputVideoFilter: string;
+    resizeVideo: string;
+    videoFps: string;
+}
+interface PreviewProps {
+    enablePreviewWeb: boolean;
+    enablePreviewLcd: string;
+    enablePreviewHdmi: string;
+}
+interface VideoProps {
+    videoConnection: string;
+    noLockedMode: 'black' | 'colorbar';
+    videoFormat: string;
+    videoCodec: 'mpeg2' | 'h264' | 'hevc' | 'hevc_qsv';
+    videoBitrate: string;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './auth.ts';
+export * from './module.ts';
+export * from './plugin.types.ts';
+export * from './protocol.ts';
+export * from './websocket.ts';
+export * from './wizard.ts';

package/dist/types/module.d.ts

@@ -0,0 +1,13 @@
+export interface ModuleDefinition {
+    id: string;
+    name: string;
+    label: string;
+    icon: string;
+    group: string;
+    path: string;
+    url: string;
+    module: string;
+}
+export interface ModulesConfig {
+    modules: ModuleDefinition[];
+}

package/dist/types/plugin.types.d.ts

@@ -0,0 +1,30 @@
+import type React from "react";
+export interface PageMetadata {
+    id: string;
+    name: string;
+    path: string;
+    url: string;
+    description?: string;
+    group?: string;
+    version?: string;
+    author?: string;
+    dependencies?: string[];
+    componentName?: string;
+}
+export interface DynamicPageComponent {
+    default: React.ComponentType<Record<string, unknown>>;
+    metadata?: Partial<PageMetadata>;
+}
+export interface PageRegistry {
+    [pageId: string]: {
+        metadata: PageMetadata;
+        component: React.ComponentType<Record<string, unknown>>;
+        loaded: boolean;
+        loadPromise?: Promise<DynamicPageComponent>;
+    };
+}
+export interface PluginLoader {
+    loadPlugin(metadata: PageMetadata): Promise<DynamicPageComponent>;
+    getLoadedPlugins(): PageRegistry;
+    unloadPlugin(pageId: string): void;
+}

package/dist/types/protocol.d.ts

@@ -0,0 +1,12 @@
+export interface ProtocolSettings {
+    protocol: string;
+    ip: string;
+    port?: string;
+    interface?: string;
+    mode?: string;
+    streamid?: string;
+    passphrase?: string;
+    hash?: string;
+    latency?: string;
+    ffurl?: string;
+}

package/dist/types/websocket.d.ts

@@ -0,0 +1,27 @@
+export interface XcoderService {
+    status: "idle" | "stoped" | "waiting_signal" | "running";
+    mode: "input" | "output";
+    sdiFormat: string;
+    log: string;
+    decklinkEvents: string;
+    name: string;
+}
+export interface SystemInfo {
+    uptime: number;
+    loadAverage: number[];
+    memoryTotal: number;
+    memoryFree: number;
+    memoryUsed: number;
+    swapTotal: number;
+    swapFree: number;
+    swapUsed: number;
+    dmesg: string;
+    cpuTemperature: number;
+    cpuClockSpeed: number;
+}
+export interface WebSocketData {
+    services: {
+        [key: string]: XcoderService;
+    };
+    system: SystemInfo;
+}

package/dist/types/wizard.d.ts

@@ -0,0 +1,12 @@
+export type PortRange = {
+    start: number;
+    end: number;
+};
+export type FinalData = {
+    step?: string;
+    deviceName?: string;
+    devicePassword?: string;
+    service1Enabled?: boolean;
+    portRange?: PortRange;
+    timestamp?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viasoftbr/shared-ui",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Shared frontend utilities, components and i18n for Viasoft plugins and micro-frontends",
   "type": "module",
   "main": "dist/index.js",
@@ -10,6 +10,22 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./index": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./context": {
+      "import": "./dist/context.js",
+      "types": "./dist/context.d.ts"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "types": "./dist/components.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    },
     "./i18n": {
       "import": "./dist/i18n.js",
       "types": "./dist/i18n.d.ts"