@tekkare/romulus 0.1.242 → 0.1.244

package/layer/app/composables/useAlerts.ts

@@ -0,0 +1,345 @@
+/**
+ * useAlerts - les alertes posees sur les vues sauvegardees.
+ *
+ * Une alerte = une vue + ce qu'on y surveille. Elle vit cote API (worker
+ * quotidien, journal d'evenements) ; ici on ne fait que lire la liste, la
+ * creer depuis la page et marquer les evenements comme lus.
+ *
+ * Le point delicat est la requete : c'est la page qui la fournit, via
+ * `useAlertSource`. Une alerte ne peut donc etre creee que depuis la page
+ * qu'elle surveille, et une vue temporaire (posee par un lien profond, jamais
+ * enregistree) n'en accepte pas : il n'y a rien a quoi l'attacher.
+ */
+import { useOipApi, type Alert, type AlertEvent, type AlertTrigger } from "#oip-app/api";
+import { sameViewPage } from "../utils/viewPages";
+
+export function useAlerts() {
+  const elysiaApi = useOipApi();
+  const source = useAlertSource();
+  const views = useViews();
+
+  const alerts = useState<Alert[]>("alerts:list", () => []);
+  /**
+   * Le mode d'essai est ouvert cote API : cadence de cinq minutes et passage
+   * manuel. Faux en production, et l'ecran n'en montre alors aucune trace.
+   */
+  const testCadence = useState<boolean>("alerts:testCadence", () => false);
+  const loaded = useState<boolean>("alerts:loaded", () => false);
+  const loading = useState<boolean>("alerts:loading", () => false);
+  /**
+   * Formulaire de creation ouvert.
+   *
+   * L'etat est partage plutot que local au panneau parce que la visite guidee
+   * des alertes doit pouvoir ouvrir le formulaire : ses etapes expliquent le
+   * parametrage, elles n'auraient rien a designer devant un panneau ferme. Le
+   * panneau le remet a faux en se demontant (cf. son composant), donc rouvrir
+   * la tuile ne rouvre pas la modale d'hier.
+   */
+  const creating = useState<boolean>("alerts:creating", () => false);
+
+  const load = async (force = false) => {
+    if (loading.value) return;
+    if (loaded.value && !force) return;
+    loading.value = true;
+    try {
+      const response = await elysiaApi.alerts.list();
+      alerts.value = response?.alerts ?? [];
+      testCadence.value = !!response?.testCadence;
+      loaded.value = true;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  /**
+   * Suit une alerte jusqu'a ce que sa reference soit posee.
+   *
+   * La capture prend quelques secondes cote worker. Sans ce suivi, la carte
+   * reste sur « en préparation » indefiniment alors que le passage a peut-etre
+   * deja echoue — et le message d'echec est justement ce qu'il faut lire.
+   */
+  const followSeeding = async (attempts = 6, delayMs = 2500) => {
+    for (let i = 0; i < attempts; i++) {
+      if (!alerts.value.some((alert) => alert.status === "seeding")) return;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      await load(true);
+    }
+  };
+
+  const router = useRouter();
+
+  /**
+   * L'alerte a ete posee depuis cette app.
+   *
+   * L'API rend les alertes de tout l'espace de travail, toutes apps
+   * confondues : sans ce tri, le panneau de France Drugs montrait celles de
+   * France Epidemio. L'hote de la vue surveillee dit d'ou elle vient. Une
+   * alerte sans URL (projet) n'appartient a aucune app : elle reste.
+   *
+   * En local, l'hote ne dit rien (les vues portent celui du staging) : on
+   * demande alors au routeur si la page existe ici.
+   */
+  const fromThisApp = (alert: Alert): boolean => {
+    if (!alert.url || !import.meta.client) return true;
+    let url: URL;
+    try {
+      url = new URL(alert.url);
+    } catch {
+      return true;
+    }
+    if (url.host === window.location.host) return true;
+    if (!/^(localhost|127\.0\.0\.1)$|\.localhost$/.test(window.location.hostname)) return false;
+    return router.resolve(url.pathname).matched.length > 0;
+  };
+
+  /**
+   * Pastille de la tuile du rail : ce que l'utilisateur n'a pas encore lu,
+   * dans cette app. Les autres apps ont leur propre pastille.
+   */
+  const unreadTotal = computed(() =>
+    alerts.value
+      .filter(fromThisApp)
+      .reduce((total, alert) => total + alert.unreadCount, 0),
+  );
+
+  /** Les alertes de la page affichee, celles que son panneau montre en premier. */
+  const forCurrentPage = computed(() => {
+    const page = views.current.value?.page;
+    if (!page) return [];
+    return alerts.value.filter((alert) => samePage(alert.page, page));
+  });
+
+  /**
+   * Vue active, quand elle existe en base.
+   *
+   * Une vue temporaire n'a pas d'identifiant (cf. `isTemporaryView`) : elle
+   * n'existe pas en base, une alerte ne peut pas s'y accrocher telle quelle.
+   */
+  const watchableView = computed(() => {
+    const active = views.active.value;
+    return active && !isTemporaryView(active) ? active : null;
+  });
+
+  /** Les vues enregistrees de la page affichee. */
+  const pageViews = computed(() => {
+    const page = views.current.value?.page;
+    if (!page) return [];
+    return views.scopes
+      .value()
+      .scopeList.value.filter((scope: any) => sameViewPage(scope.page, page));
+  });
+
+  /**
+   * Une alerte peut naitre des que la page sait livrer sa requete et qu'il y
+   * a de quoi la rattacher : une vue deja enregistree, ou des filtres a
+   * l'ecran dont on fera une vue.
+   *
+   * Ne pas exiger une vue ACTIVE : c'est la modale qui choisit, et exiger
+   * l'application prealable obligeait a passer par un autre panneau avant de
+   * pouvoir cliquer.
+   *
+   * Sans source declaree, il reste l'alerte de MARQUE : elle ne surveille
+   * aucune page, donc aucune requete d'ecran ne lui manque, et depuis que
+   * l'API accepte une alerte sans pulse, aucune vue non plus. C'est ce qui
+   * ouvre les alertes aux pages de ventes (Medic'AM, delivrances
+   * hospitalieres, statistiques), dont les ecrans sont des agregats, et aux
+   * pages qui nomment un produit sans rien offrir a filtrer : la fiche
+   * produit, l'ecran de recherche.
+   */
+  const canCreate = computed(() => {
+    if (source.brands.value.length > 0) return true;
+    // Sans requete, une alerte de marque suffit : les produits de la vue
+    // affichee, enregistree ou non, en font une. Exiger une vue en base
+    // grisait le bouton sur tout le portail des qu'aucune vue n'existait sur
+    // ce domaine, alors que la selection etait bien a l'ecran.
+    if (!source.current.value) {
+      return (
+        pageViews.value.length > 0 ||
+        viewBrandsFromCriteria(views.current.value?.criteria?.() ?? []).length > 0
+      );
+    }
+    return (
+      pageViews.value.length > 0 ||
+      (views.current.value?.criteria?.().length ?? 0) > 0
+    );
+  });
+
+  const create = async (payload: {
+    title: string;
+    /** `product` : des marques, sur tout le hub. Defaut : une vue. */
+    kind?: "view" | "product";
+    brands?: string[];
+    /** Vue a surveiller. Absent : la vue active. */
+    viewId?: string | null;
+    triggers: AlertTrigger[];
+    watchedFields: string[];
+    channels?: string[];
+    cadence?: string;
+    visibility?: "private" | "workspace";
+  }) => {
+    const declared = source.current.value;
+    const product = payload.kind === "product";
+    // La vue nommee par la modale l'emporte : elle vient d'etre appliquee a
+    // l'ecran, donc c'est bien elle que la requete decrit. Pas de repli sur
+    // la premiere vue de la page : quand la vue active est temporaire,
+    // l'alerte s'accrocherait a une vue qui n'a rien a voir avec l'ecran.
+    //
+    // Une alerte de produit, elle, ne surveille aucune vue : elle nomme des
+    // marques, couvre tous les index du hub et ne tient d'aucune page. Elle
+    // garde pourtant l'identifiant de la vue active quand il y en a une : c'est
+    // par lui que `useAlertBrandSync` la retrouve pour proposer de suivre les
+    // marques de la vue. Il ne sert qu'a ce lien, jamais a l'affichage, qui se
+    // decide sur `kind`.
+    const pulseId = product
+      ? (watchableView.value?.id ?? null)
+      : (payload.viewId ?? watchableView.value?.id ?? null);
+    if (!product && (!pulseId || !declared)) return null;
+
+    const alert = await elysiaApi.alerts.create({
+      pulseId: pulseId ?? undefined,
+      kind: payload.kind,
+      brands: payload.brands,
+      title: payload.title,
+      // Une alerte de produit n'a ni index ni requete : le moteur les engendre
+      // pour les sept index du hub.
+      index: product ? undefined : declared!.index,
+      // Relue maintenant : c'est l'ecran tel qu'il est, pas tel qu'il etait a
+      // l'ouverture du panneau.
+      query: product ? undefined : declared!.query(),
+      resourceType: product ? undefined : declared!.resourceType,
+      // L'API nomme l'app par son registre quand elle connait l'hote ; ce
+      // nom-ci sert de repli, pour que le digest ne dise pas « OIP » a un
+      // client tant que l'app n'y est pas inscrite.
+      appName: String(useRuntimeConfig().public.app_name ?? "") || undefined,
+      watchedFields: payload.watchedFields,
+      // Les libelles partent avec l'alerte : seule l'app les traduit, et le
+      // digest ne peut pas ecrire `last_price_update` dans la boite d'un
+      // client.
+      fieldLabels: Object.fromEntries(
+        (declared?.fields ?? [])
+          .filter(
+            (field) =>
+              // « * » suit le document entier : tous les libelles servent.
+              payload.watchedFields.includes("*") ||
+              payload.watchedFields.includes(field.value),
+          )
+          .map((field) => [field.value, field.label]),
+      ),
+      labelFields: product ? ["label", "brand"] : declared!.labelFields,
+      triggers: payload.triggers,
+      channels: payload.channels,
+      cadence: payload.cadence,
+      visibility: payload.visibility,
+    });
+
+    if (alert) {
+      alerts.value = [alert, ...alerts.value];
+      // Pas d'attente : la modale se ferme, la carte se met a jour derriere.
+      followSeeding();
+    }
+    return alert;
+  };
+
+  const update = async (
+    id: string,
+    payload: Parameters<typeof elysiaApi.alerts.update>[1],
+  ) => {
+    const updated = await elysiaApi.alerts.update(id, payload);
+    if (updated) {
+      alerts.value = alerts.value.map((alert) =>
+        alert.id === id ? { ...alert, ...updated } : alert,
+      );
+    }
+    return updated;
+  };
+
+  const remove = async (id: string) => {
+    await elysiaApi.alerts.delete(id);
+    alerts.value = alerts.value.filter((alert) => alert.id !== id);
+  };
+
+  /**
+   * Repointe une alerte perimee sur la requete courante de la page.
+   *
+   * Ne marche que depuis la page surveillee, seule a savoir construire la
+   * requete. L'alerte repart d'une nouvelle reference : l'ancienne repondait a
+   * une autre question.
+   */
+  const rearm = async (id: string) => {
+    const declared = source.current.value;
+    if (!declared) return null;
+    const result = await elysiaApi.alerts.rearm(id, {
+      query: declared.query(),
+      index: declared.index,
+    });
+    await load(true);
+    return result;
+  };
+
+  /** Rejoue une alerte et relit la liste : le resultat se voit tout de suite. */
+  const runNow = async (id: string) => {
+    const result = await elysiaApi.alerts.run(id);
+    await load(true);
+    return result;
+  };
+
+  /** Envoie son propre digest tout de suite. */
+  const simulate = async (
+    id: string,
+    payload: { kind?: "appeared" | "changed" | "disappeared"; count?: number; sources?: number } = {},
+  ) => {
+    const result = await elysiaApi.alerts.simulate(id, payload);
+    await load(true);
+    return result;
+  };
+
+  const sendDigestNow = async () => elysiaApi.alerts.runDigest();
+
+  const events = async (id: string, limit = 50): Promise<AlertEvent[]> => {
+    const response = await elysiaApi.alerts.events(id, limit);
+    return response?.events ?? [];
+  };
+
+  const markRead = async (payload: { alertId?: string; eventIds?: string[] }) => {
+    const result = await elysiaApi.alerts.markRead(payload);
+    if (payload.alertId) {
+      alerts.value = alerts.value.map((alert) =>
+        alert.id === payload.alertId ? { ...alert, unreadCount: 0 } : alert,
+      );
+    }
+    return result;
+  };
+
+  return {
+    alerts,
+    loading,
+    creating,
+    load,
+    followSeeding,
+    unreadTotal,
+    fromThisApp,
+    forCurrentPage,
+    watchableView,
+    pageViews,
+    canCreate,
+    create,
+    update,
+    remove,
+    rearm,
+    events,
+    markRead,
+    testCadence,
+    runNow,
+    simulate,
+    sendDigestNow,
+  };
+}
+
+/**
+ * Deux chemins qui designent la meme page. Meme raison que dans `useViews` :
+ * `trailingSlash` est actif et les vues d'un lien profond portent le chemin
+ * sans barre finale.
+ */
+function samePage(a: unknown, b: unknown): boolean {
+  return String(a ?? "").replace(/\/$/, "") === String(b ?? "").replace(/\/$/, "");
+}

package/layer/app/composables/useExportSource.ts

@@ -0,0 +1,236 @@
+/**
+ * useExportSource - ce qu'une page donne a exporter.
+ *
+ * Le panneau d'export (`RmExportPanel`, via `LayoutToolExport`) vit dans le
+ * cadre, pas dans la page : il ne peut pas savoir ce que l'ecran affiche. Une
+ * page declare donc sa source ici, et le cadre s'adapte — la tuile Export ne
+ * sort que sur les pages qui en ont une, et les formats proposes dependent de
+ * ce que la source contient (pas de graphique declare, pas de PNG).
+ *
+ * Le registre est un `shallowRef` de module, rempli au montage et vide au
+ * demontage : une page qui quitte l'ecran emporte sa source, et rien ne
+ * traverse le rendu serveur (les descripteurs portent des fonctions, qui ne
+ * survivraient pas a la serialisation du payload Nuxt).
+ */
+import { useExportDirectusSources } from "#oip-app/export";
+import type {
+  RmExportCard,
+  RmExportFilter,
+  RmExportFormat,
+  RmExportKpi,
+  RmExportRange,
+  RmExportSheet,
+  RmExportSource as RmSource,
+  RmExportTemplate,
+} from "@tekkare/romulus/utils/export";
+
+export interface ExportSource {
+  /** Titre du document exporte. */
+  title: string;
+  subtitle?: string;
+  /** Nom de fichier propose, sans extension (cf. rmExportFileName). */
+  fileName: string;
+  /** Onglets du classeur, dans la forme deja utilisee par les exports XLSX. */
+  sheets: RmExportSheet[];
+  kpi?: RmExportKpi[];
+  sources?: RmSource[];
+  filters?: RmExportFilter[];
+  /** Plages proposees a l'etape « Donnees ». Vide : pas de choix de plage. */
+  ranges?: RmExportRange[];
+  /**
+   * Plages qui partent avec TOUTES les colonnes : le choix des colonnes
+   * disparait du panneau et chaque onglet garde son schema entier.
+   *
+   * « Toute la donnee » d'une fiche produit est une demande d'archive, pas de
+   * mise en forme : faire cocher des colonnes d'un onglet a l'autre n'a pas de
+   * sens quand le classeur en porte quinze de natures differentes.
+   */
+  fullRanges?: string[];
+  /** Catalogue de formats, si la page en restreint la liste. */
+  formats?: RmExportFormat[];
+  /**
+   * Modeles de depart propres a la page, poses a la place de la tuile Excel
+   * generique du catalogue.
+   *
+   * Une fiche produit porte dix onglets de natures differentes : « Data brute
+   * Excel » ne dit pas lequel part dans le fichier. La page nomme donc ses
+   * propres depart (« toute la donnee de KEYTRUDA », « KEYTRUDA HAS ») en
+   * preselectionnant la plage qui va avec. Les autres tuiles (rapport PDF,
+   * lien partageable) restent celles du cadre : leur libelle ne depend pas de
+   * l'ecran.
+   */
+  templates?: RmExportTemplate[];
+  /**
+   * Graphiques exportables. Retourne des noeuds du DOM : les charts sont
+   * rendus en SVG, on les recupere tels quels plutot qu'en capture d'ecran.
+   */
+  charts?: () => { title?: string; el: Element }[];
+  /**
+   * Forme de la page, pour les formats mis en page (le rapport PDF).
+   *
+   * `cards` : une liste de resultats, une fiche par ligne, comme les pages de
+   * recherche du hub les empilent. `table` : un ecran d'analyse, ou la lecture
+   * est le tableau lui-meme et ou une fiche par ligne n'aurait aucun sens.
+   * Sans valeur, la forme est deduite du rendu (`visibleExportLayout`) : une
+   * liste de fiches donne `cards`, un ecran de graphiques et de tableaux donne
+   * `table`.
+   */
+  layout?: "cards" | "table";
+  /**
+   * Ce que l'ecran montre, relu au moment de l'export.
+   *
+   * Les formats mis en page (PDF) doivent ressembler a la page : ses tableaux,
+   * ses fiches, ses chiffres cles, avec les titres qu'elle affiche. `sheets`,
+   * lui, reste la donnee complete, celle du classeur : dix mille lignes dans un
+   * rapport ne se lisent pas.
+   *
+   * Sans ce point d'entree, le panneau relit l'ecran lui-meme
+   * (`visibleExportScreen`) : une page n'a rien a declarer pour que son rapport
+   * lui ressemble, elle n'a a le faire que si le rendu ne suffit pas.
+   */
+  screen?: () => { sheets?: RmExportSheet[]; kpi?: RmExportKpi[]; cards?: RmExportCard[] };
+  /** Plafond de lignes par onglet. */
+  limit?: number;
+  /**
+   * Motif pour lequel la page refuse d'exporter sa donnee en l'etat : la
+   * selection couvre trop d'entites. Le cadre l'affiche a l'ouverture du
+   * panneau et grise les formats qui emportent des enregistrements ; les
+   * formats sans enregistrement (image d'un graphique, lien partageable)
+   * restent proposes. Refuser plutot que rogner : la moitie d'un perimetre se
+   * lit comme un resultat complet.
+   */
+  blocked?: string;
+  /** URL a partager pour le format « Permalink ». Defaut : l'URL courante. */
+  permalink?: () => string;
+  /**
+   * Appele a l'ouverture du panneau.
+   *
+   * Les pages du portail ne gardent pas leurs lignes d'export en memoire :
+   * c'est une requete plafonnee a 10 000 lignes, la charger a l'affichage de
+   * la page serait la payer sans que personne l'ait demandee. Sans ce point
+   * d'entree, le panneau s'ouvrirait sur des onglets vides et son etape
+   * « Colonnes » n'aurait rien a proposer avant le clic sur Exporter.
+   */
+  prepare?: () => void | Promise<void>;
+  /**
+   * Appele des que la plage change a l'etape « Donnees », avant l'export.
+   *
+   * A implementer quand la plage change les COLONNES : l'etape suivante lit
+   * les onglets de la page pour lister ce qu'on peut decocher, et une colonne
+   * qui n'existe que dans l'autre plage n'y figurerait pas. Le rechargement
+   * des lignes, lui, reste dans `beforeExport` : personne n'a a payer une
+   * requete pour avoir clique sur un bouton radio.
+   */
+  onRange?: (range: string) => void | Promise<void>;
+  /**
+   * Appele avant de generer, avec la plage retenue : c'est la que la page
+   * recharge ses donnees quand l'utilisateur demande toute la base plutot que
+   * la page courante.
+   */
+  beforeExport?: (range: string) => void | Promise<void>;
+  /** Nom de l'export dans PostHog. Defaut : le nom de fichier. */
+  posthogName?: string;
+}
+
+/**
+ * Une seule source a la fois : c'est la page visible qui la porte. Le
+ * descripteur peut rendre `null` — une fiche produit declare sa source avant
+ * que la fiche soit chargee, et n'a rien a exporter tant qu'elle est vide.
+ */
+const registry = shallowRef<(() => ExportSource | null) | null>(null);
+
+/**
+ * Sources de la page affichee, lues dans Directus : le meme referentiel que le
+ * panneau « Sources » du rail, avec sa `latest_download_date`. Posees par le
+ * cadre (layout), elles valent pour le panneau d'export comme pour le menu
+ * de chaque carte et le bouton d'export inline (`provideRmExportDefaults`).
+ */
+const pageSources = shallowRef<RmSource[]>([]);
+
+/**
+ * Un export demande depuis une autre tuile (le raccourci « Exporter en Excel »
+ * d'une carte de vue), par son format. Le panneau d'export le lit a son
+ * montage, le lance avec sa recette par defaut et l'efface : la tuile Export
+ * est la seule a savoir generer, et elle n'est montee que quand elle est
+ * ouverte.
+ */
+const quick = useState<string | null>("export:quick", () => null);
+
+/**
+ * Declare les sources de la page a partir des uuids que le cadre suit deja
+ * pour son panneau « Sources ». A appeler dans le `setup` du layout.
+ */
+export function providePageExportSources(uuids: Ref<string[]>) {
+  const { locale } = useI18n();
+  const { load, exportSources } = useExportDirectusSources();
+  const route = useRoute();
+  const permalink = usePermalink();
+
+  watch(uuids, (list) => list.length && load(list), { immediate: true });
+  watchEffect(() => {
+    pageSources.value = exportSources(uuids.value, locale.value);
+  });
+
+  // Le lien que copie le menu d'une carte : le permalien de l'ecran, vue et
+  // filtres compris, le meme que la tuile « Lien partageable ». L'URL courante
+  // ne disait rien de ce qui etait affiche, et « lien direct » promettait plus.
+  // Recalcule quand la page ou ses criteres bougent : `build` les lit avant
+  // sa premiere attente, `route.fullPath` suit la navigation.
+  const pageLink = shallowRef<string | undefined>(undefined);
+  watchEffect(async () => {
+    void route.fullPath;
+    if (!import.meta.client) return;
+    try {
+      pageLink.value = await permalink.build();
+    } catch {
+      pageLink.value = undefined;
+    }
+  });
+
+  // Les sources sont un etat de module : sans nettoyage, celles du dernier
+  // cadre monte restaient en place quand on changeait de portail, et la page
+  // de garde d'un export PHMEV citait les sources du hub.
+  onScopeDispose(() => {
+    pageSources.value = [];
+  });
+
+  provideRmExportDefaults(() => ({ sources: pageSources.value, permalink: pageLink.value }));
+}
+
+export function useExportSource() {
+  /**
+   * Declare la source de la page courante. A appeler dans le `setup` d'un
+   * composant de la page : la source est posee au montage et retiree au
+   * demontage, donc la tuile Export suit la navigation sans nettoyage manuel.
+   */
+  function declare(build: () => ExportSource | null) {
+    // Page du tiroir de projet : l'export reste celui de l'ecran dessous.
+    if (useHubrEmbedded()) return;
+    onMounted(() => {
+      registry.value = build;
+    });
+    onBeforeUnmount(() => {
+      if (registry.value === build) registry.value = null;
+    });
+    // Page gardee en vie (keepalive, la fiche projet) : elle ne se remonte pas
+    // au retour, la tuile Export disparaissait apres l'ouverture d'une fiche.
+    onActivated(() => {
+      registry.value = build;
+    });
+    onDeactivated(() => {
+      if (registry.value === build) registry.value = null;
+    });
+  }
+
+  return {
+    declare,
+    /** Format d'un export a lancer des que le panneau s'ouvre (cf. ci-dessus). */
+    quick,
+    /** La source courante, relue a chaque acces : elle suit les filtres. */
+    current: computed(() => registry.value?.() ?? null),
+    /** Vrai quand la page declare une source qui a effectivement du contenu. */
+    has: computed(() => (registry.value?.() ?? null) !== null),
+    /** Sources Directus de la page, avec leur date de mise a jour. */
+    pageSources: computed(() => pageSources.value),
+  };
+}

package/layer/app/composables/useHubrEmbedded.ts

@@ -0,0 +1,13 @@
+import { hasInjectionContext, inject, type InjectionKey } from "vue";
+
+/**
+ * Vrai sous une page montee dans le tiroir de la fiche projet (cf.
+ * HubrEmbeddedPage). La page y vit par-dessus un autre ecran : ce qu'elle
+ * declare au cadre (export, alertes) remplacerait ce que declare l'ecran
+ * dessous, et le retirerait a la fermeture du tiroir.
+ */
+export const HUBR_EMBEDDED: InjectionKey<boolean> = Symbol("hubr-embedded");
+
+export function useHubrEmbedded(): boolean {
+  return hasInjectionContext() ? inject(HUBR_EMBEDDED, false) : false;
+}