teraprox-core-sdk 0.2.0 → 0.3.2

package/dist/federation-B4ShfmDd.d.ts

@@ -0,0 +1,259 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React__default, { Dispatch } from 'react';
+
+interface HttpController {
+    get(path?: string, query?: string): Promise<any>;
+    post(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    put(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    patch(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    delete(path?: string, id?: string | number, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    deleteSimple(path?: string, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    save(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    read(path?: string, id?: string | number, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    readAll(path?: string, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    readAllwithPage(path?: string, page?: number, size?: number): Promise<any>;
+    bulkDelete(path?: string, ids?: (string | number)[], extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+}
+
+interface ToastOptions {
+    autoDismiss?: boolean;
+    autoDismissTimeout?: number;
+}
+interface ToastService {
+    success(message: string, options?: ToastOptions): void;
+    warning(message: string, options?: ToastOptions): void;
+    error(message: string, options?: ToastOptions): void;
+    info(message: string, options?: ToastOptions): void;
+}
+
+interface MatchingObjectSubscription {
+    context: string;
+    location: string;
+    refresher?: (payload: any, dispatch: Dispatch<any>) => void;
+    persist?: boolean;
+    userId?: string;
+}
+
+interface CoreService {
+    /** Cria um HttpController configurado para um contexto/endpoint */
+    createController(context: string, baseEndPoint?: string): HttpController;
+    /** Serviço de toast/notificações */
+    toast: ToastService;
+    /** Subscreve a um MatchingObject (real-time via Firebase RTDB) */
+    subscribe(mo: MatchingObjectSubscription): void;
+    /** Remove subscrição de um MatchingObject */
+    unsubscribe(mo: MatchingObjectSubscription): void;
+    /** Subscreve a eventos de MatchingObject via EventTarget */
+    subscribeEvent(context: string, location: string, handler: EventListenerOrEventListenerObject): void;
+    /** Remove subscrição de evento de MatchingObject */
+    unsubscribeEvent(context: string, location: string, handler: EventListenerOrEventListenerObject): void;
+    /** Encerra a sessão do usuário */
+    handleLogout(): void;
+    /** Indica se o componente está hospedado pelo Core */
+    hostedByCore: boolean;
+}
+
+interface FederatedBridgeProps {
+    /**
+     * CoreService completo injetado pelo host.
+     * O host monta este valor a partir do seu WebProvider interno.
+     */
+    coreService: CoreService;
+    children: React__default.ReactNode;
+}
+/**
+ * Bridge padronizado para módulos federados.
+ *
+ * Responsibilities:
+ * 1. Marks window.__TERAPROX_HOSTED_BY_CORE__ = true
+ * 2. Provides CoreServiceContext with host value
+ *
+ * USAGE IN REMOTES:
+ * ```
+ * // remote/src/federation/FederatedBridge.js
+ * export { FederatedBridge as default } from 'teraprox-core-sdk/federation'
+ * ```
+ */
+declare function FederatedBridge({ coreService, children }: FederatedBridgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Factory for creating a standardized ReducersBundle.
+ *
+ * Each remote only needs to declare ITS reducers and context map.
+ * Resolution, deduplication, and loading logic lives here in the SDK.
+ *
+ * USAGE IN REMOTES:
+ * ```
+ * import { createReducersBundle } from 'teraprox-core-sdk/federation'
+ *
+ * export default createReducersBundle({
+ *   reducers: {
+ *     ordemDeServico: () => import('../Reducers/osReducer'),
+ *     ordemDeManutencao: () => import('../Reducers/omReducer'),
+ *   },
+ *   contextMap: {
+ *     visaoGeral: ['ordemDeServico', 'ordemDeManutencao'],
+ *     ordemDeServico: ['ordemDeServico'],
+ *   },
+ *   defaults: ['picker', 'globalError'],
+ * })
+ * ```
+ */
+interface ReducersBundleConfig {
+    /** Map de nome → importador lazy do reducer */
+    reducers: Record<string, () => Promise<any>>;
+    /** Map de contexto → lista de reducer keys necessárias */
+    contextMap: Record<string, string[]>;
+    /** Keys carregadas em TODOS os contextos */
+    defaults?: string[];
+}
+interface ReducersBundle {
+    getReducerKeysByContext(context: string): string[];
+    getReducersForKeys(keys: string[]): Promise<Record<string, any>>;
+    getReducersForModule(opts: {
+        context?: string;
+        modulePath?: string;
+    }): Promise<Record<string, any>>;
+    loadAllReducers(): Promise<Record<string, any>>;
+    baseReducers: Record<string, never>;
+}
+declare function createReducersBundle(config: ReducersBundleConfig): ReducersBundle;
+
+interface StandaloneConfig {
+    /**
+     * Factory for creating an HttpController. The remote provides its
+     * local implementation (using basicController + axios).
+     */
+    createController: (context: string, baseEndPoint?: string) => HttpController;
+    /** Toast function from react-toast-notifications */
+    addToast: (message: string, options?: any) => void;
+    /**
+     * Firebase client config object (from REACT_APP_FIREBASE_CONFIG).
+     * When provided together with `tenant`, enables real-time matching
+     * object listening via Firebase RTDB — same path the Core uses.
+     *
+     * If omitted, the provider auto-detects the RTDB emulator:
+     *   1. Reads `REACT_APP_RTDB_EMULATOR_HOST` (e.g. `localhost:9000`)
+     *   2. Falls back to probing `localhost:9000`
+     *   3. If neither works, shows a configuration popup (dev only)
+     */
+    firebaseConfig?: Record<string, unknown>;
+    /**
+     * Tenant / company ID used to build the RTDB path:
+     * `{tenant}/matchingObjects`
+     */
+    tenant?: string;
+    children: React__default.ReactNode;
+}
+/**
+ * Standardized provider for standalone mode (npm start).
+ *
+ * Replaces the StandaloneCoreServiceProvider that each remote copies.
+ * The remote only needs to provide its createController and addToast.
+ *
+ * RTDB auto-resolution order (no config required):
+ *   1. `REACT_APP_RTDB_EMULATOR_HOST` env var → connects to emulator
+ *   2. `firebaseConfig` prop → connects to Firebase cloud
+ *   3. Auto-probe `localhost:9000` → uses emulator if alive
+ *   4. None found → shows configuration popup (dev only)
+ *
+ * USAGE IN REMOTES:
+ * ```
+ * import { StandaloneProvider } from 'teraprox-core-sdk/federation'
+ * import { basicController } from '../Http/basicController'
+ * import { useToasts } from 'react-toast-notifications'
+ *
+ * function App() {
+ *   const { addToast } = useToasts()
+ *   const tenant = useSelector(s => s.global.companyId)
+ *   return (
+ *     <StandaloneProvider
+ *       createController={(ctx, ep) => basicController(ctx, ep)}
+ *       addToast={addToast}
+ *       tenant={tenant}
+ *     >
+ *       <Routes />
+ *     </StandaloneProvider>
+ *   )
+ * }
+ * ```
+ */
+declare function StandaloneProvider({ createController, addToast, firebaseConfig, tenant, children }: StandaloneConfig): react_jsx_runtime.JSX.Element;
+
+interface DevUser {
+    firstName: string;
+    lastName: string;
+    token: string;
+    email: string;
+    id: string;
+    role: string;
+    user: string;
+    userName: string;
+    setor: string;
+    userSetor: {
+        setorId: string;
+    };
+    companyName: string;
+    companyId: string;
+    filters: any[];
+}
+interface DevAutoLoginProps {
+    /** Redux actions from the remote's globalConfigReducer */
+    actions: {
+        logIn: (user: any) => any;
+        setCompany: (company: string) => any;
+    };
+    /** Mock data for dev (optional, has defaults) */
+    devUser?: Partial<DevUser>;
+    children: React__default.ReactNode;
+}
+/**
+ * Auto-login for standalone dev mode.
+ *
+ * USAGE:
+ * ```
+ * import { DevAutoLogin } from 'teraprox-core-sdk/federation'
+ * import { logIn, setCompany } from '../Reducers/globalConfigReducer'
+ *
+ * <DevAutoLogin actions={{ logIn, setCompany }}>
+ *   <App />
+ * </DevAutoLogin>
+ * ```
+ */
+declare function DevAutoLogin({ actions, devUser, children }: DevAutoLoginProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Manifesto que cada remote exporta para o Core
+ * montar menu e rotas dinamicamente.
+ */
+interface RemoteMenuItem {
+    /** Label exibido no menu */
+    label: string;
+    /** Rota no react-router (ex: '/manutencao/ordens-de-servico') */
+    path: string;
+    /** Nome do módulo no exposes do webpack (ex: './OrdensDeServico') */
+    module: string;
+    /** Contexto para ReducersBundle (ex: 'ordemDeServico') */
+    context: string;
+    /** ID do componente para withPermission */
+    componentId?: string;
+    /** Ícone react-icons (ex: 'FaTools') */
+    icon?: string;
+}
+interface RemoteMenuSection {
+    /** Nome da seção no menu (ex: 'Manutenção') */
+    label: string;
+    /** Ícone da seção */
+    icon?: string;
+    items: RemoteMenuItem[];
+}
+interface RemoteManifest {
+    /** Nome do remote (deve corresponder ao name do ModuleFederationPlugin) */
+    name: string;
+    /** Versão semântica */
+    version: string;
+    /** Seções de menu que este remote contribui */
+    menuSections: RemoteMenuSection[];
+}
+
+export { type CoreService as C, DevAutoLogin as D, FederatedBridge as F, type HttpController as H, type MatchingObjectSubscription as M, type ReducersBundle as R, StandaloneProvider as S, type ToastService as T, type ReducersBundleConfig as a, type RemoteManifest as b, type RemoteMenuItem as c, type RemoteMenuSection as d, type ToastOptions as e, createReducersBundle as f };

package/dist/federation.d.mts

@@ -0,0 +1,3 @@
+export { D as DevAutoLogin, F as FederatedBridge, R as ReducersBundle, a as ReducersBundleConfig, b as RemoteManifest, c as RemoteMenuItem, d as RemoteMenuSection, S as StandaloneProvider, f as createReducersBundle } from './federation-B4ShfmDd.mjs';
+import 'react/jsx-runtime';
+import 'react';

package/dist/federation.d.ts

@@ -0,0 +1,3 @@
+export { D as DevAutoLogin, F as FederatedBridge, R as ReducersBundle, a as ReducersBundleConfig, b as RemoteManifest, c as RemoteMenuItem, d as RemoteMenuSection, S as StandaloneProvider, f as createReducersBundle } from './federation-B4ShfmDd.js';
+import 'react/jsx-runtime';
+import 'react';

package/dist/federation.js

@@ -0,0 +1,358 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/federation.ts
+var federation_exports = {};
+__export(federation_exports, {
+  DevAutoLogin: () => DevAutoLogin,
+  FederatedBridge: () => FederatedBridge,
+  StandaloneProvider: () => StandaloneProvider,
+  createReducersBundle: () => createReducersBundle
+});
+module.exports = __toCommonJS(federation_exports);
+
+// src/federation/FederatedBridge.tsx
+var import_react2 = require("react");
+
+// src/context/CoreServiceContext.ts
+var import_react = require("react");
+var CoreServiceContext = (0, import_react.createContext)(null);
+
+// src/federation/FederatedBridge.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function FederatedBridge({ coreService, children }) {
+  (0, import_react2.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    window.__TERAPROX_HOSTED_BY_CORE__ = true;
+    return () => {
+      ;
+      window.__TERAPROX_HOSTED_BY_CORE__ = false;
+    };
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CoreServiceContext.Provider, { value: coreService, children });
+}
+
+// src/federation/createReducersBundle.ts
+function createReducersBundle(config) {
+  const { reducers, contextMap, defaults = [] } = config;
+  const allKeys = Object.keys(reducers);
+  const getReducerKeysByContext = (context) => {
+    const contextKeys = contextMap[context];
+    if (!contextKeys) return allKeys;
+    return [.../* @__PURE__ */ new Set([...defaults, ...contextKeys])];
+  };
+  const getReducersForKeys = async (keys = []) => {
+    const uniqueKeys = [...new Set(keys)].filter((key) => !!reducers[key]);
+    const loaded = await Promise.all(
+      uniqueKeys.map(async (key) => {
+        const module2 = await reducers[key]();
+        return [key, module2.default || module2];
+      })
+    );
+    return Object.fromEntries(loaded);
+  };
+  const getReducersForModule = async ({
+    context
+  } = {}) => {
+    const keys = getReducerKeysByContext(context || "");
+    return getReducersForKeys(keys);
+  };
+  const loadAllReducers = () => getReducersForKeys(allKeys);
+  return {
+    getReducerKeysByContext,
+    getReducersForKeys,
+    getReducersForModule,
+    loadAllReducers,
+    baseReducers: {}
+  };
+}
+
+// src/federation/StandaloneProvider.tsx
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+async function probeEmulator(host, port) {
+  try {
+    const res = await fetch(`http://${host}:${port}/.json`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    return res.ok || res.status === 404;
+  } catch (e) {
+    return false;
+  }
+}
+async function resolveRtdbStrategy(firebaseConfig) {
+  var _a;
+  const emulatorHostEnv = typeof process !== "undefined" && process.env.REACT_APP_RTDB_EMULATOR_HOST || void 0;
+  if (emulatorHostEnv) {
+    const [host, portStr] = emulatorHostEnv.split(":");
+    const port = parseInt(portStr != null ? portStr : "9000", 10);
+    const namespace = (_a = process.env.REACT_APP_RTDB_EMULATOR_NS) != null ? _a : "demo-local";
+    return { type: "emulator", host, port, namespace };
+  }
+  if (firebaseConfig && Object.keys(firebaseConfig).length > 0) {
+    return { type: "cloud", config: firebaseConfig };
+  }
+  const alive = await probeEmulator("localhost", 9e3);
+  if (alive) {
+    return { type: "emulator", host: "localhost", port: 9e3, namespace: "demo-local" };
+  }
+  return { type: "none" };
+}
+var _emulatorConnected = /* @__PURE__ */ new Set();
+function RtdbConfigWarning({ onDismiss }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        bottom: 24,
+        right: 24,
+        zIndex: 99999,
+        background: "#1a1a2e",
+        color: "#fff",
+        borderRadius: 8,
+        padding: "16px 20px",
+        maxWidth: 420,
+        boxShadow: "0 4px 24px rgba(0,0,0,0.5)",
+        borderLeft: "4px solid #f59e0b",
+        fontFamily: "monospace",
+        fontSize: 13,
+        lineHeight: 1.6
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { fontWeight: "bold", marginBottom: 8, color: "#f59e0b", fontSize: 14 }, children: "\u26A0 RTDB n\xE3o configurado" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
+          "Matching Objects em tempo real desativados.",
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+          "Configure no ",
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { children: ".env.dev" }),
+          ":",
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { style: { color: "#86efac" }, children: "REACT_APP_RTDB_EMULATOR_HOST=localhost:9000" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: { color: "#94a3b8", fontSize: 11 }, children: [
+            "ou inicie o backend com ",
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { children: "RtdbEmulatorPlugin" }),
+            " do @onroad/core"
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("br", {}),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: { color: "#94a3b8", fontSize: 11 }, children: [
+            "e rode o emulator com ",
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("code", { children: "firebase emulators:start --only database" })
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "button",
+          {
+            onClick: onDismiss,
+            style: {
+              marginTop: 12,
+              padding: "4px 14px",
+              background: "#374151",
+              color: "#fff",
+              border: "none",
+              borderRadius: 4,
+              cursor: "pointer",
+              fontSize: 12
+            },
+            children: "Fechar"
+          }
+        )
+      ]
+    }
+  );
+}
+function StandaloneProvider({ createController, addToast, firebaseConfig, tenant, children }) {
+  const [subscriptions] = (0, import_react3.useState)([]);
+  const subscriptionsRef = (0, import_react3.useRef)(subscriptions);
+  subscriptionsRef.current = subscriptions;
+  const [rtdbWarning, setRtdbWarning] = (0, import_react3.useState)(false);
+  const toast = (0, import_react3.useMemo)(
+    () => ({
+      success: (msg, opts) => addToast(msg, { appearance: "success", autoDismiss: true, ...opts }),
+      warning: (msg, opts) => addToast(msg, { appearance: "warning", autoDismiss: true, ...opts }),
+      error: (msg, opts) => addToast(msg, { appearance: "error", autoDismiss: true, ...opts }),
+      info: (msg, opts) => addToast(msg, { appearance: "info", autoDismiss: true, ...opts })
+    }),
+    [addToast]
+  );
+  const subscribe = (0, import_react3.useCallback)(
+    (mo) => {
+      subscriptions.push(mo);
+    },
+    [subscriptions]
+  );
+  const unsubscribe = (0, import_react3.useCallback)(
+    (mo) => {
+      const idx = subscriptions.findIndex(
+        (s) => s.context === mo.context && s.location === mo.location
+      );
+      if (idx >= 0) subscriptions.splice(idx, 1);
+    },
+    [subscriptions]
+  );
+  (0, import_react3.useEffect)(() => {
+    if (!tenant) return;
+    let cleanup;
+    let cancelled = false;
+    (async () => {
+      var _a;
+      const strategy = await resolveRtdbStrategy(firebaseConfig);
+      if (cancelled) return;
+      if (strategy.type === "none") {
+        if (process.env.NODE_ENV !== "production") setRtdbWarning(true);
+        return;
+      }
+      try {
+        const { initializeApp, getApps } = await import("firebase/app");
+        const { getDatabase, ref, onChildAdded } = await import("firebase/database");
+        let db;
+        if (strategy.type === "emulator") {
+          const appName = `onroad-rtdb-emulator-${strategy.port}`;
+          const existingApp = getApps().find((a) => a.name === appName);
+          const emulatorApp = existingApp != null ? existingApp : initializeApp(
+            {
+              projectId: strategy.namespace,
+              databaseURL: `http://${strategy.host}:${strategy.port}?ns=${strategy.namespace}`
+            },
+            appName
+          );
+          db = getDatabase(emulatorApp);
+          if (!_emulatorConnected.has(appName)) {
+            const { connectDatabaseEmulator } = await import("firebase/database");
+            try {
+              connectDatabaseEmulator(db, strategy.host, strategy.port);
+              _emulatorConnected.add(appName);
+            } catch (e) {
+              _emulatorConnected.add(appName);
+            }
+          }
+          console.info(
+            `[StandaloneProvider] RTDB emulator at ${strategy.host}:${strategy.port} (ns=${strategy.namespace})`
+          );
+        } else {
+          const existingApp = (_a = getApps().find((a) => a.name === "[DEFAULT]")) != null ? _a : getApps()[0];
+          const cloudApp = existingApp != null ? existingApp : initializeApp(strategy.config);
+          db = getDatabase(cloudApp);
+        }
+        const moRef = ref(db, `${tenant}/matchingObjects`);
+        const unsub = onChildAdded(moRef, (snapshot) => {
+          const data = snapshot.val();
+          if (!data) return;
+          const items = Array.isArray(data) ? data : [data];
+          for (const mo of items) {
+            if (typeof mo !== "object") continue;
+            const subs = subscriptionsRef.current || [];
+            for (const sub of subs) {
+              const sameContext = sub.context === mo.context;
+              const sameLocation = sub.location === mo.location || sub.location === "*" || mo.location === "*" || !sub.location || !mo.location;
+              if (sameContext && sameLocation && sub.refresher) {
+                try {
+                  sub.refresher(mo.payload, () => {
+                  });
+                } catch (e) {
+                }
+              }
+            }
+          }
+        });
+        cleanup = () => unsub();
+      } catch (err) {
+        console.warn("[StandaloneProvider] Firebase RTDB listener failed:", err);
+      }
+    })();
+    return () => {
+      cancelled = true;
+      cleanup == null ? void 0 : cleanup();
+    };
+  }, [firebaseConfig, tenant]);
+  const value = (0, import_react3.useMemo)(
+    () => ({
+      createController,
+      toast,
+      subscribe,
+      unsubscribe,
+      subscribeEvent: () => {
+      },
+      unsubscribeEvent: () => {
+      },
+      handleLogout: () => {
+      },
+      hostedByCore: false
+    }),
+    [createController, toast, subscribe, unsubscribe]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(CoreServiceContext.Provider, { value, children: [
+    children,
+    rtdbWarning && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RtdbConfigWarning, { onDismiss: () => setRtdbWarning(false) })
+  ] });
+}
+
+// src/federation/DevAutoLogin.tsx
+var import_react4 = require("react");
+var import_react_redux = require("react-redux");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var DEFAULT_DEV_USER = {
+  firstName: "Dev",
+  lastName: "User",
+  token: "dev-standalone-token",
+  email: "dev@teraprox.local",
+  id: "dev-user-id",
+  role: "admin",
+  user: "devuser",
+  userName: "devuser",
+  setor: "Desenvolvimento",
+  userSetor: { setorId: "dev-setor-id" },
+  companyName: "Dev Company",
+  companyId: "dev-company-id",
+  filters: []
+};
+function DevAutoLogin({ actions, devUser, children }) {
+  const dispatch = (0, import_react_redux.useDispatch)();
+  const token = (0, import_react_redux.useSelector)((state) => {
+    var _a;
+    return (_a = state.global) == null ? void 0 : _a.token;
+  });
+  const hostedByCore = typeof window !== "undefined" && window.__TERAPROX_HOSTED_BY_CORE__ === true;
+  (0, import_react4.useEffect)(() => {
+    if (process.env.NODE_ENV === "development" && !hostedByCore && !token) {
+      const user = { ...DEFAULT_DEV_USER, ...devUser };
+      dispatch(actions.setCompany(user.companyId));
+      dispatch(actions.logIn(user));
+    }
+  }, [dispatch, hostedByCore, token, actions, devUser]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevAutoLogin,
+  FederatedBridge,
+  StandaloneProvider,
+  createReducersBundle
+});

package/dist/federation.mjs

@@ -0,0 +1,12 @@
+import {
+  DevAutoLogin,
+  FederatedBridge,
+  StandaloneProvider,
+  createReducersBundle
+} from "./chunk-PATJPPYP.mjs";
+export {
+  DevAutoLogin,
+  FederatedBridge,
+  StandaloneProvider,
+  createReducersBundle
+};