@viasoftbr/shared-ui 0.0.7-1 → 0.0.7-3

package/dist/services.js

@@ -2766,19 +2766,24 @@ function formatAxiosError(err) {
   return err instanceof Error ? err : new Error(String(err));
 }
 var fetchApi = {
-  getJson: async (path, params, headers) => {
+  getJson: async (path, params, headersOrOptions) => {
     try {
-      const response = await (path.includes("/auth") ? authApi : api).get(path.replace("/auth", ""), { params, headers });
+      const requestOptions = normalizeRequestOptions(params, headersOrOptions);
+      const response = await (path.includes("/auth") ? authApi : api).get(path.replace("/auth", ""), {
+        params: withTokenQueryParams(requestOptions),
+        headers: requestOptions.headers
+      });
       return response.data;
     } catch (e) {
       throw formatAxiosError(e);
     }
   },
-  getText: async (path, params, headers) => {
+  getText: async (path, params, headersOrOptions) => {
     try {
+      const requestOptions = normalizeRequestOptions(params, headersOrOptions);
       const response = await (path.includes("/auth") ? authApi : api).get(path.replace("/auth", ""), {
-        params,
-        headers,
+        params: withTokenQueryParams(requestOptions),
+        headers: requestOptions.headers,
         responseType: "text"
       });
       return response.data;
@@ -2786,65 +2791,104 @@ var fetchApi = {
       throw formatAxiosError(e);
     }
   },
-  getVoid: async (path, params, headers) => {
+  getVoid: async (path, params, headersOrOptions) => {
     try {
-      await (path.includes("/auth") ? authApi : api).get(path.replace("/auth", ""), { params, headers });
+      const requestOptions = normalizeRequestOptions(params, headersOrOptions);
+      await (path.includes("/auth") ? authApi : api).get(path.replace("/auth", ""), {
+        params: withTokenQueryParams(requestOptions),
+        headers: requestOptions.headers
+      });
     } catch (e) {
       throw formatAxiosError(e);
     }
   },
-  postJson: async (path, payload, headers) => {
+  postJson: async (path, payload, headersOrOptions) => {
     try {
-      const response = await (path.includes("/auth") ? authApi : api).post(path.replace("/auth", ""), payload, { headers });
+      const requestOptions = normalizeRequestOptions(void 0, headersOrOptions);
+      const response = await (path.includes("/auth") ? authApi : api).post(path.replace("/auth", ""), payload, {
+        headers: requestOptions.headers,
+        params: withTokenQueryParams(requestOptions)
+      });
       return response.data;
     } catch (e) {
       throw formatAxiosError(e);
     }
   },
-  patchJson: async (path, payload, headers) => {
+  patchJson: async (path, payload, headersOrOptions) => {
     try {
-      const response = await (path.includes("/auth") ? authApi : api).patch(path.replace("/auth", ""), payload, { headers });
+      const requestOptions = normalizeRequestOptions(void 0, headersOrOptions);
+      const response = await (path.includes("/auth") ? authApi : api).patch(path.replace("/auth", ""), payload, {
+        headers: requestOptions.headers,
+        params: withTokenQueryParams(requestOptions)
+      });
       return response.data;
     } catch (e) {
       throw formatAxiosError(e);
     }
   },
-  putJson: async (path, payload, headers) => {
+  putJson: async (path, payload, headersOrOptions) => {
     try {
-      const response = await (path.includes("/auth") ? authApi : api).put(path.replace("/auth", ""), payload, { headers });
+      const requestOptions = normalizeRequestOptions(void 0, headersOrOptions);
+      const response = await (path.includes("/auth") ? authApi : api).put(path.replace("/auth", ""), payload, {
+        headers: requestOptions.headers,
+        params: withTokenQueryParams(requestOptions)
+      });
       return response.data;
     } catch (e) {
       throw formatAxiosError(e);
     }
   },
-  deleteJson: async (path, headers) => {
+  deleteJson: async (path, headersOrOptions) => {
     try {
-      const response = await (path.includes("/auth") ? authApi : api).delete(path.replace("/auth", ""), { headers });
+      const requestOptions = normalizeRequestOptions(void 0, headersOrOptions);
+      const response = await (path.includes("/auth") ? authApi : api).delete(path.replace("/auth", ""), {
+        headers: requestOptions.headers,
+        params: withTokenQueryParams(requestOptions)
+      });
       return response.data;
     } catch (e) {
       throw formatAxiosError(e);
     }
   },
-  deleteVoid: async (path, headers) => {
+  deleteVoid: async (path, headersOrOptions) => {
     try {
-      await (path.includes("/auth") ? authApi : api).delete(path.replace("/auth", ""), { headers });
+      const requestOptions = normalizeRequestOptions(void 0, headersOrOptions);
+      await (path.includes("/auth") ? authApi : api).delete(path.replace("/auth", ""), {
+        headers: requestOptions.headers,
+        params: withTokenQueryParams(requestOptions)
+      });
     } catch (e) {
       throw formatAxiosError(e);
     }
   }
 };
-function buildWsUrl(path = "/") {
+function buildWsUrl(path = "/", options = {}) {
   try {
     const origin2 = new URL(apiOrigin);
     origin2.protocol = origin2.protocol === "https:" ? "wss:" : "ws:";
     if (!path.startsWith("/"))
       path = "/" + path;
     origin2.pathname = path;
-    return origin2.toString();
+    return withAccessTokenQuery(origin2.toString(), {
+      headers: options.headers,
+      params: options.query,
+      token: options.token ?? options.bearerToken,
+      tokenQueryParam: options.tokenQueryParam ?? options.bearerQueryParam,
+      includeStoredToken: options.includeStoredToken
+    });
   } catch (e) {
     const proto = apiOrigin.startsWith("https") ? "wss" : "ws";
     const host = apiOrigin.replace(/^https?:\/\//, "").replace(/\/$/, "");
-    return `${proto}://${host}${path.startsWith("/") ? path : "/" + path}`;
+    return withAccessTokenQuery(
+      `${proto}://${host}${path.startsWith("/") ? path : "/" + path}`,
+      {
+        headers: options.headers,
+        params: options.query,
+        token: options.token ?? options.bearerToken,
+        tokenQueryParam: options.tokenQueryParam ?? options.bearerQueryParam,
+        includeStoredToken: options.includeStoredToken
+      }
+    );
   }
 }
 function extractBearerToken(headers, explicitToken) {
@@ -2858,17 +2902,41 @@ function extractBearerToken(headers, explicitToken) {
   const match = authHeader.match(/^Bearer\s+(.+)$/i);
   return match ? match[1] : null;
 }
-function appendWsQueryParam(url, key, value) {
+function resolveAuthToken(options = {}) {
+  const explicitToken = options.token ?? options.bearerToken ?? null;
+  const headerToken = extractBearerToken(options.headers, explicitToken);
+  if (headerToken)
+    return headerToken;
+  if (options.includeStoredToken === false)
+    return null;
+  return getAccessToken();
+}
+function mergeQueryParams(params, key, value) {
+  const nextParams = { ...params ?? {} };
+  if (key && value)
+    nextParams[key] = value;
+  return Object.keys(nextParams).length > 0 ? nextParams : void 0;
+}
+function appendQueryParams(url, params) {
+  if (!params || Object.keys(params).length === 0)
+    return url;
   try {
     const parsed = new URL(
       url,
       typeof window !== "undefined" ? window.location.href : void 0
     );
-    parsed.searchParams.set(key, value);
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null)
+        continue;
+      parsed.searchParams.set(key, String(value));
+    }
     return parsed.toString();
   } catch {
+    const search = Object.entries(params).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+    if (!search)
+      return url;
     const separator = url.includes("?") ? "&" : "?";
-    return `${url}${separator}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+    return `${url}${separator}${search}`;
   }
 }
 function normalizeProtocols(protocols) {
@@ -2876,6 +2944,39 @@ function normalizeProtocols(protocols) {
     return void 0;
   return Array.isArray(protocols) ? protocols.filter(Boolean) : [protocols];
 }
+function normalizeRequestOptions(params, headersOrOptions) {
+  const maybeOptions = headersOrOptions;
+  const hasOptionShape = Boolean(
+    maybeOptions && ("headers" in maybeOptions || "params" in maybeOptions || "sendTokenInQuery" in maybeOptions || "token" in maybeOptions || "tokenQueryParam" in maybeOptions || "includeStoredToken" in maybeOptions)
+  );
+  if (hasOptionShape) {
+    return {
+      ...maybeOptions,
+      params: { ...params ?? {}, ...maybeOptions?.params ?? {} }
+    };
+  }
+  return {
+    params,
+    headers: headersOrOptions
+  };
+}
+function withTokenQueryParams(options) {
+  if (!options.sendTokenInQuery)
+    return options.params;
+  const token = resolveAuthToken(options);
+  return mergeQueryParams(
+    options.params,
+    options.tokenQueryParam ?? "access_token",
+    token
+  );
+}
+function withAccessTokenQuery(url, options = {}) {
+  const token = resolveAuthToken(options);
+  return appendQueryParams(
+    url,
+    mergeQueryParams(options.params, options.tokenQueryParam ?? "access_token", token)
+  );
+}
 async function encodeFfurl(settings) {
   const { ffurl } = await fetchApi.postJson("/auth/protocols/ffurl/encode", settings);
   return ffurl;
@@ -2885,9 +2986,14 @@ async function decodeFfurl(ffurl) {
   return settings;
 }
 function subscribeToWebsocket(url, onMessage, options = {}) {
-  const bearerToken = extractBearerToken(options.headers, options.bearerToken);
-  const bearerStrategy = options.bearerStrategy ?? "query";
-  let resolvedUrl = url;
+  const bearerToken = resolveAuthToken({
+    headers: options.headers,
+    token: options.token,
+    bearerToken: options.bearerToken,
+    includeStoredToken: options.includeStoredToken
+  });
+  const bearerStrategy = options.tokenTransport ?? options.bearerStrategy ?? "query";
+  let resolvedUrl = appendQueryParams(url, options.query);
   const protocols = normalizeProtocols(options.protocols) ?? [];
   if (options.headers && Object.keys(options.headers).length > 0) {
     console.warn(
@@ -2898,11 +3004,11 @@ function subscribeToWebsocket(url, onMessage, options = {}) {
     if (bearerStrategy === "protocol") {
       protocols.push("bearer", bearerToken);
     } else {
-      resolvedUrl = appendWsQueryParam(
-        url,
-        options.bearerQueryParam ?? "access_token",
-        bearerToken
-      );
+      resolvedUrl = withAccessTokenQuery(resolvedUrl, {
+        token: bearerToken,
+        tokenQueryParam: options.tokenQueryParam ?? options.bearerQueryParam,
+        includeStoredToken: false
+      });
     }
   }
   const socket = protocols.length > 0 ? new WebSocket(resolvedUrl, protocols) : new WebSocket(resolvedUrl);
@@ -3151,5 +3257,6 @@ export {
   setAccessToken,
   setRefreshToken,
   subscribeToWebsocket,
-  userService
+  userService,
+  withAccessTokenQuery
 };

package/dist/types/websocket.d.ts

@@ -25,10 +25,21 @@ export interface WebSocketData {
     };
     system: SystemInfo;
 }
+export type AuthTokenTransport = 'query' | 'protocol';
+export interface AuthTokenQueryOptions {
+    token?: string | null;
+    tokenQueryParam?: string;
+    includeStoredToken?: boolean;
+}
 export interface WebSocketSubscribeOptions {
     headers?: Record<string, string>;
     protocols?: string | string[];
+    query?: Record<string, string | number | boolean | null | undefined>;
+    tokenTransport?: AuthTokenTransport;
+    token?: string | null;
+    tokenQueryParam?: string;
+    includeStoredToken?: boolean;
     bearerToken?: string | null;
-    bearerStrategy?: 'query' | 'protocol';
+    bearerStrategy?: AuthTokenTransport;
     bearerQueryParam?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viasoftbr/shared-ui",
-  "version": "0.0.7-1",
+  "version": "0.0.7-3",
   "main": "./dist/index.js",
   "types": "./dist/types/index.d.ts",
   "exports": {

package/dist/components/RemoteModule.d.ts

@@ -1,8 +0,0 @@
-interface RemoteModuleProps {
-    scope: string;
-    url: string;
-    module: string;
-    fallback?: React.ReactNode;
-}
-export declare function RemoteModule({ scope, url, module, fallback }: RemoteModuleProps): import("react/jsx-runtime").JSX.Element;
-export default RemoteModule;

package/dist/package.json

@@ -1,111 +0,0 @@
-{
-  "name": "@viasoftbr/shared-ui",
-  "version": "0.0.3",
-  "description": "Shared frontend utilities, components and i18n for Viasoft plugins and micro-frontends",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "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/index.d.ts"
-    },
-    "./components": {
-        "import": "./dist/components.js",
-        "types": "./dist/components/index.d.ts"
-    },
-    "./services": {
-        "import": "./dist/services.js",
-        "types": "./dist/services/index.d.ts"
-    },
-    "./types": {
-        "import": "./dist/types.js",
-        "types": "./dist/types/index.d.ts"
-    },
-    "./i18n": {
-        "import": "./dist/i18n.js",
-        "types": "./dist/i18n.d.ts"
-    },
-    "./jsmpeg": {
-      "default": "./dist/jsmpeg.vu.min.js"
-    },
-    "./locales/*": {
-      "default": "./dist/locales/*"
-    }
-  },
-  "scripts": {
-    "build": "node scripts/build.js",
-    "dev": "node scripts/build.js --watch",
-    "typecheck": "tsc --noEmit"
-  },
-  "peerDependencies": {
-    "react": "^19.0.0"
-  },
-  "devDependencies": {
-    "@types/react": "^19.2.13",
-    "esbuild": "^0.20.0",
-    "typescript": "^5.0.0"
-  },
-  "files": [
-    "dist"
-  ],
-  "overrides": {
-    "use-sync-external-store": "1.6.1"
-  },
-  "resolutions": {
-    "use-sync-external-store": "1.6.1"
-  },
-  "pnpm": {
-    "overrides": {
-      "use-sync-external-store": "1.6.1"
-    }
-  },
-  "keywords": [
-    "viasoft",
-    "shared",
-    "utils",
-    "components",
-    "i18n",
-    "microfrontend"
-  ],
-  "author": "Viasoft",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@headlessui/react": "^2.2.9",
-    "@reduxjs/toolkit": "^2.10.1",
-    "@tanstack/react-query": "^5.90.10",
-    "@types/react-dom": "^19.2.3",
-    "@viasoftbr/shared-utils": "^0.0.1",
-    "axios": "^1.13.2",
-    "i18next": "^25.7.3",
-    "json-server": "1.0.0-beta.3",
-    "lucide-react": "^0.460.0",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "react-i18next": "^16.5.0",
-    "react-redux": "^9.2.0",
-    "react-router-dom": "^6.20.1",
-    "react-tooltip": "^5.30.0",
-    "redux-batch-middleware": "^0.2.0",
-    "tailwind-scrollbar": "^4.0.2"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/viasoftbr/shared-ui.git"
-  },
-  "bugs": {
-    "url": "https://github.com/viasoftbr/shared-ui/issues"
-  },
-  "homepage": "https://github.com/viasoftbr/shared-ui#readme"
-}

package/dist/services/loadRemoteModule.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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;