@tekkare/romulus 0.1.242 → 0.1.244

package/layer/app/composables/usePermalink.ts

@@ -0,0 +1,108 @@
+/**
+ * usePermalink - l'URL d'un ecran filtre, et sa relecture a l'arrivee.
+ *
+ * Le format « Permalink » du panneau d'export copiait l'URL de la page. Or les
+ * filtres d'un ecran du hub ne sont pas dans l'URL : ils vivent dans le magasin
+ * de scopes (cf. `useViews`). Le lien partage ouvrait donc la page nue, avec la
+ * vue par defaut du destinataire, et pas l'ecran que l'expediteur avait sous
+ * les yeux.
+ *
+ * Un permalink porte donc les criteres de la page, dans la forme exacte d'une
+ * vue : le lien est une vue temporaire transportee par l'URL. A l'arrivee, ils
+ * sont reposes par le meme chemin qu'une vue appliquee, et la vue par defaut de
+ * la page leur cede la place (cf. `useViews().declare`).
+ *
+ * Les criteres voyagent compresses, en base64url : le routeur aplatit les
+ * tableaux imbriques d'une requete, et un JSON pose tel quel dans l'URL en
+ * ressortirait deforme. La compression n'est pas une coquetterie — une
+ * selection de cinquante produits fait 3 300 caracteres en clair, au-dela de ce
+ * qu'un client mail transmet sans couper, contre 450 compressee. Elle est
+ * portee par `CompressionStream`, native, donc rien a installer.
+ */
+
+/** Parametre de requete qui porte les criteres d'un lien partage. */
+export const PERMALINK_PARAM = "vue";
+
+/**
+ * Premier caractere de la charge : il dit comment lire la suite. Un navigateur
+ * sans `CompressionStream` ecrit en clair, et le lien reste lisible par les
+ * autres.
+ */
+const DEFLATED = "1";
+const PLAIN = "0";
+
+function toBase64Url(bytes: Uint8Array): string {
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+function fromBase64Url(raw: string): Uint8Array {
+  const binary = atob(raw.replace(/-/g, "+").replace(/_/g, "/"));
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+
+/** Passe des octets dans un flux de (de)compression et rend le resultat. */
+async function through(bytes: Uint8Array, stream: TransformStream): Promise<Uint8Array> {
+  const blob = new Blob([bytes as BlobPart]);
+  const piped = blob.stream().pipeThrough(stream);
+  return new Uint8Array(await new Response(piped).arrayBuffer());
+}
+
+/**
+ * La charge a poser dans l'URL pour ces criteres. Compressee quand le
+ * navigateur sait le faire, en clair sinon.
+ */
+async function encode(criteria: any[]): Promise<string> {
+  const bytes = new TextEncoder().encode(JSON.stringify(criteria));
+  if (typeof CompressionStream === "undefined") return PLAIN + toBase64Url(bytes);
+  // « deflate-raw » et pas « deflate » : l'en-tete zlib ne sert a rien ici, et
+  // ce sont six caracteres de base64 en moins sur chaque lien.
+  return DEFLATED + toBase64Url(await through(bytes, new CompressionStream("deflate-raw")));
+}
+
+/**
+ * Les criteres portes par une URL, dans la forme de ceux d'une vue. Vide quand
+ * le lien n'en porte pas — ou quand il a ete tronque par un client mail : la
+ * page s'ouvre alors sur ses propres filtres plutot que sur une erreur.
+ */
+export async function permalinkCriteria(query: Record<string, any>): Promise<any[]> {
+  const raw = query?.[PERMALINK_PARAM];
+  if (typeof raw !== "string" || raw.length < 2) return [];
+
+  try {
+    const bytes = fromBase64Url(raw.slice(1));
+    const json =
+      raw[0] === DEFLATED
+        ? new TextDecoder().decode(await through(bytes, new DecompressionStream("deflate-raw")))
+        : new TextDecoder().decode(bytes);
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+export function usePermalink() {
+  const views = useViews();
+
+  /**
+   * L'URL a partager pour l'ecran courant. Sans filtre pose, c'est l'URL de la
+   * page : un lien vide de criteres n'a rien a transporter.
+   */
+  async function build(): Promise<string> {
+    const url = new URL(window.location.href);
+    url.searchParams.delete(PERMALINK_PARAM);
+
+    // Meme lecture que la sauvegarde d'une vue et que le recapitulatif d'un
+    // rapport : un filtre ajoute a une page suit sans retouche ici.
+    const criteria = views.criteriaOf().filter((item: any) => viewFilledValues(item).length > 0);
+    if (criteria.length > 0) url.searchParams.set(PERMALINK_PARAM, await encode(criteria));
+
+    return url.toString();
+  }
+
+  return { build };
+}

package/layer/app/composables/useSavedExports.ts

@@ -0,0 +1,286 @@
+/**
+ * useSavedExports - les exports deja tires, conserves dans le compte.
+ *
+ * Un export n'est pas un fichier stocke : les documents partent du navigateur
+ * et personne ne les garde. Ce qui est conserve, c'est la *recette* : la
+ * configuration du wizard, plus les filtres poses a l'ecran au moment du
+ * tirage. Rejouer un export repose donc ces filtres et regenere le document
+ * avec la donnee du jour.
+ *
+ * Le magasin est celui des vues : les pulses de `elysiaApi.pulses`, le seul
+ * endroit ou le hub sait deja ranger quelque chose par utilisateur, par app et
+ * par page. Deux marques les distinguent d'une vue :
+ *
+ * - `page` porte le prefixe `export:`. Les listes de vues filtrent sur
+ *   l'egalite avec la page courante (cf. `layout/tool/views.vue` et la
+ *   pastille), donc un export prefixe n'y parait jamais et la vue par defaut
+ *   d'une page ne peut pas tomber sur lui.
+ * - la configuration voyage dans un critere nomme `__export`, comme l'etat du
+ *   « Personnaliser » voyage dans `__cardPrefs` : `criteria` est le seul champ
+ *   libre du pulse.
+ *
+ * Les criteres qui restent sont donc lisibles tels quels par les composants de
+ * filtre, et rejouer un export emprunte exactement le chemin d'une vue
+ * appliquee.
+ */
+import type { RmExportConfig } from "@tekkare/romulus/utils/export";
+import { useOipApi } from "#oip-app/api";
+import { normalizePage } from "../utils/viewTemplates";
+
+/** Prefixe de `pulse.page` qui distingue un export d'une vue. */
+const EXPORT_PAGE_PREFIX = "export:";
+
+/** Critere qui porte la configuration du wizard. Ce n'est pas un filtre. */
+export const EXPORT_CONFIG_FILTER = "__export";
+
+/**
+ * Nombre d'exports gardes. Au-dela, les plus anciens partent : la liste est
+ * un historique consultable, pas une archive, et une page en tire plusieurs
+ * par session.
+ */
+const KEPT = 20;
+
+export interface SavedExport {
+  id: string;
+  /** Nom du fichier tel qu'il est sorti. */
+  title: string;
+  /** Ecran d'origine, sans le prefixe. */
+  page: string;
+  /** Titre de cet ecran, garde avec l'entree. */
+  pageLabel: string;
+  /** Dernier tirage : un rejeu remplace l'entree, il n'en cree pas une autre. */
+  at: string;
+  format: string;
+  rows?: number;
+  size?: string;
+  config: RmExportConfig;
+  /** Filtres du moment du tirage, dans la forme des criteres d'une vue. */
+  criteria: any[];
+}
+
+/**
+ * Liste partagee entre les montages du panneau : la tuile monte et demonte le
+ * composant a chaque ouverture, un etat local repartirait vide. `useState`
+ * plutot qu'un `ref` de module : la liste porte de la donnee d'utilisateur, et
+ * un ref de module est partage par toutes les requetes d'un meme serveur.
+ */
+const useList = () => useState<SavedExport[]>("oip-saved-exports", () => []);
+
+function parseCriteria(pulse: any): any[] {
+  const raw = pulse?.criteria;
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw !== "string") return [];
+  try {
+    return JSON.parse(raw) ?? [];
+  } catch {
+    return [];
+  }
+}
+
+/** Un pulse prefixe devient une entree, ou rien s'il ne porte pas de config. */
+function toSavedExport(pulse: any): SavedExport | null {
+  const criteria = parseCriteria(pulse);
+  const entry = criteria.find((item: any) => item?.filter === EXPORT_CONFIG_FILTER);
+  const raw = Array.isArray(entry?.values) ? entry.values[0] : null;
+  if (typeof raw !== "string") return null;
+
+  let payload: any;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!payload?.config?.format) return null;
+
+  return {
+    id: String(pulse.id),
+    title: String(pulse.title ?? ""),
+    page: String(pulse.page ?? "").slice(EXPORT_PAGE_PREFIX.length),
+    pageLabel: String(pulse.description ?? ""),
+    // La date du dernier tirage voyage dans la config : un rejeu ecrit le
+    // meme pulse, et `createdAt` resterait celle du premier. Les entrees
+    // d'avant ce champ retombent dessus.
+    at: String(payload.at ?? pulse.createdAt ?? pulse.updatedAt ?? ""),
+    format: String(payload.config.format),
+    rows: typeof payload.rows === "number" ? payload.rows : undefined,
+    size: typeof payload.size === "string" ? payload.size : undefined,
+    config: payload.config as RmExportConfig,
+    criteria: criteria.filter((item: any) => item?.filter !== EXPORT_CONFIG_FILTER),
+  };
+}
+
+export function useSavedExports() {
+  const list = useList();
+  const elysiaApi = useOipApi();
+  const views = useViews();
+  const route = useRoute();
+
+  /**
+   * Page de rangement : celle que la page a declaree, sinon la route. Sans le
+   * prefixe de langue : les pages declarent `route.path`, et « Mes exports »
+   * se vidait au passage de `/fr/` a `/en/`.
+   */
+  const pageKey = () => normalizePage(views.current.value?.page ?? route.path);
+
+  /** Les exports du compte pour cette app, les plus recents d'abord. */
+  async function load() {
+    try {
+      // Meme plafond que les listes de vues : les deux lisent le meme magasin,
+      // et un compte charge tronquerait sinon son propre historique.
+      const response = await elysiaApi.pulses.list({
+        domain: window.location.host,
+        limit: 500,
+      });
+      list.value = response.data
+        .filter((pulse: any) => String(pulse.page ?? "").startsWith(EXPORT_PAGE_PREFIX))
+        .map(toSavedExport)
+        .filter((entry): entry is SavedExport => entry !== null)
+        .sort((a, b) => b.at.localeCompare(a.at));
+    } catch (error) {
+      // Compte sans acces aux pulses, ou API muette : l'onglet reste vide
+      // plutot que de faire echouer l'export lui-meme.
+      console.error("[useSavedExports] chargement impossible", error);
+      list.value = [];
+    }
+  }
+
+  interface ExportEntry {
+    title: string;
+    /** Titre de l'ecran d'origine, garde avec l'entree. */
+    pageLabel: string;
+    config: RmExportConfig;
+    rows?: number;
+    size?: string;
+  }
+
+  /** Les filtres de l'ecran, suivis de la config du tirage. */
+  function criteriaFor(entry: ExportEntry, page: string) {
+    return [
+      // Les filtres de l'ecran, lus la ou les vues les lisent : un filtre
+      // ajoute a une page suit sans retouche ici.
+      ...views.criteriaOf(),
+      {
+        filter: EXPORT_CONFIG_FILTER,
+        page,
+        values: [
+          JSON.stringify({
+            config: entry.config,
+            rows: entry.rows,
+            size: entry.size,
+            at: new Date().toISOString(),
+          }),
+        ],
+      },
+    ];
+  }
+
+  /**
+   * Garde l'export qui vient de partir. Appele apres coup : un echec
+   * d'enregistrement ne doit pas priver l'utilisateur de son fichier, il est
+   * deja telecharge.
+   *
+   * `replaces` nomme l'entree rejouee : un rejeu refait le meme document a
+   * partir de la meme recette, il met a jour son entree (date, lignes, taille)
+   * au lieu d'empiler un doublon a chaque clic.
+   */
+  async function save(entry: ExportEntry, replaces?: string) {
+    const page = pageKey();
+    try {
+      if (replaces) {
+        await elysiaApi.pulses.update(replaces, {
+          title: entry.title,
+          criteria: criteriaFor(entry, page),
+        });
+      } else {
+        await elysiaApi.pulses.create({
+          title: entry.title,
+          description: entry.pageLabel,
+          url: window.location.href,
+          page: `${EXPORT_PAGE_PREFIX}${page}`,
+          criteria: criteriaFor(entry, page),
+        });
+      }
+      await load();
+      await trim();
+    } catch (error) {
+      console.error("[useSavedExports] enregistrement impossible", error);
+    }
+  }
+
+  /** Retire les entrees au-dela du plafond, les plus anciennes d'abord. */
+  async function trim() {
+    const surplus = list.value.slice(KEPT);
+    if (surplus.length === 0) return;
+    await Promise.all(
+      surplus.map((entry) =>
+        elysiaApi.pulses
+          .delete(entry.id)
+          .catch((error) => console.error("[useSavedExports] purge impossible", error)),
+      ),
+    );
+    list.value = list.value.slice(0, KEPT);
+  }
+
+  async function remove(id: string) {
+    const kept = list.value.filter((entry) => entry.id !== id);
+    try {
+      await elysiaApi.pulses.delete(id);
+      list.value = kept;
+    } catch (error) {
+      console.error("[useSavedExports] suppression impossible", error);
+    }
+  }
+
+  /**
+   * Repose les filtres que porte un export.
+   *
+   * Meme chemin qu'une vue appliquee : les composants de filtre de heart
+   * ecoutent la reference de `selectedScope`, drugsstats et le portail passent
+   * par `onApply`. La vue posee n'a ni identifiant ni titre, comme celle d'un
+   * lien partage : l'ecran ne correspond plus a une vue enregistree, la
+   * pastille le dit (« Vue temporaire ») plutot que de porter le nom de
+   * l'export.
+   *
+   * Un export tire sans filtre repose un ecran vierge : garder les filtres du
+   * moment aurait donne un autre perimetre que celui de l'export.
+   *
+   * Rend ce que `onApply` rend : il est type `void`, mais une page qui
+   * renverrait sa promesse de rechargement serait attendue par le rejeu.
+   */
+  async function applyFilters(entry: SavedExport) {
+    const source = views.current.value;
+    if (!source) return;
+
+    if (entry.criteria.length === 0) {
+      views.resetAll();
+      return;
+    }
+
+    const scope = {
+      id: null,
+      title: "",
+      page: source.page,
+      criteria: JSON.stringify(entry.criteria),
+    };
+    views.scopes.value().setSelectedScope(scope);
+    views.applyPrefs(scope, source.prefsScope);
+    await source.onApply?.(scope);
+  }
+
+  return {
+    /**
+     * Les exports de l'ecran courant, et eux seuls : un export nomme les
+     * filtres et les colonnes d'une page, il ne se lit pas depuis une autre.
+     * La liste complete reste chargee derriere : le plafond se compte par
+     * compte et non par page, et `find` cherche par identifiant.
+     */
+    list: computed(() => list.value.filter((entry) => entry.page === pageKey())),
+    /** Vrai quand l'export a ete tire de l'ecran courant : il peut se rejouer. */
+    isHere: (entry: SavedExport) => entry.page === pageKey(),
+    find: (id: string) => list.value.find((entry) => entry.id === id) ?? null,
+    load,
+    save,
+    remove,
+    applyFilters,
+  };
+}