@tekkare/romulus 0.1.231 → 0.1.233

package/dist/runtime/utils/projects.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Les projets Virtual Lab : un dossier partage ou l'utilisateur range ce qu'il
+ * croise dans les apps OIP (un essai, une publication, un avis HAS...).
+ *
+ * L'API ne garde d'un element que sa paire (resourceId, resourceType). Pour
+ * l'afficher, une app relit le document dans Elasticsearch, et c'est tout ce
+ * qu'elle a a decrire : une « famille » (`RmProjectKind`) dit dans quel index
+ * chercher, comment titrer le document et ou mene son lien. Le reste (les
+ * lignes, la recherche, le tri, les groupes de projets, le resume d'un projet)
+ * vit ici, pour que toutes les apps affichent n'importe quel projet de la
+ * meme facon, y compris les familles rangees depuis une autre app des qu'elles
+ * en connaissent la description.
+ *
+ * Les composants RmProject* ne font aucun appel : ils recoivent ces objets et
+ * rendent des intentions (ajouter, ouvrir, retirer). Les types sont ici et pas
+ * dans les `.vue` : le paquet n'expose que `utils/*`, et une app qui construit
+ * ces objets doit pouvoir les typer.
+ */
+export type RmProjectLang = 'fr' | 'en';
+/** Un projet, tel que les listes l'affichent. */
+export interface RmProject {
+    id: string;
+    title: string;
+    description?: string;
+    createdAt?: string;
+    /** Proprietaire : nom affiche, a defaut l'email. */
+    ownerName?: string;
+    /** Le lecteur en est le proprietaire. */
+    mine?: boolean;
+    /** Ouvert a l'espace de travail ou a d'autres personnes. */
+    shared?: boolean;
+    /** Ressources presentes, toutes familles confondues. Absent : non compte. */
+    resourcesCount?: number;
+    pinned?: boolean;
+    /** Lien vers la page du projet. */
+    to?: string;
+}
+export interface RmProjectGroup {
+    key: 'pinned' | 'mine' | 'shared';
+    label: string;
+    projects: RmProject[];
+}
+/**
+ * Une famille de ressources : ce qu'une app sait relire et afficher.
+ *
+ * `S` est la forme du `_source` Elasticsearch. L'identifiant range est
+ * toujours l'`_id` du document : c'est par lui que l'API verifie un ajout.
+ */
+export interface RmProjectKind<S = any> {
+    /** Valeur de `resourceType` cote API. */
+    type: string;
+    index: string;
+    label: Record<RmProjectLang, string>;
+    /** Rubrique de l'app d'ou vient la famille (Essais, Publications...). */
+    section?: Record<RmProjectLang, string>;
+    /** Icone Phosphor. */
+    icon: string;
+    /** Champs a relire. Absent : le document entier. */
+    source?: string[];
+    title: (source: S, lang: RmProjectLang) => string;
+    subtitle?: (source: S, lang: RmProjectLang) => string;
+    /** Chemin de la fiche dans l'app, sans prefixe de langue. */
+    path?: (source: S, id: string) => string;
+    /** Titre lisible dans l'identifiant seul, quand le document a disparu. */
+    titleFromId?: (id: string) => string;
+}
+/** Un element du projet, tel que l'API le rend. */
+export interface RmProjectItem {
+    resourceId: string;
+    resourceType: string;
+    createdAt?: string;
+    /** Commentaires et citations dans les notes. */
+    commentsCount?: number;
+}
+/** Une ligne de ressource, prete a afficher. */
+export interface RmProjectResource {
+    id: string;
+    type: string;
+    /** Vide quand le document n'a pas ete retrouve. */
+    title: string;
+    subtitle?: string;
+    path?: string;
+    /** Libelle de la famille. */
+    family: string;
+    section?: string;
+    icon: string;
+    createdAt?: string;
+    comments?: number;
+    /** La famille est decrite par l'app. Faux : element range ailleurs. */
+    known: boolean;
+    /** Le document relu, pour un affichage propre a l'app. */
+    source?: unknown;
+}
+/** Une fiche refusee parce qu'archivee, nommee pour la question a poser. */
+export interface RmProjectArchivedEntry {
+    key: string;
+    label: string;
+}
+/** Une rangee du cadrage, deduite par l'app de ce que le projet range. */
+export interface RmProjectScopeRow {
+    key: string;
+    label: string;
+    icon: string;
+    values: string[];
+    /** Texte quand la rangee est vide. */
+    none?: string;
+}
+/** Une facon d'avancer : un onglet du projet. */
+export interface RmProjectStep {
+    tab: string;
+    icon: string;
+    title: string;
+    text: string;
+}
+/**
+ * Une entree du fil d'une ressource : un commentaire, ou une note du projet
+ * qui la cite (avec les passages qui la citent).
+ */
+export interface RmProjectCommentEntry {
+    id: string;
+    author?: string;
+    date?: string;
+    text?: string;
+    /** Presente quand l'entree est une note qui cite la ressource. */
+    note?: {
+        id: string;
+        title?: string;
+        icon?: string;
+        private?: boolean;
+        excerpts?: string[];
+    };
+}
+export type RmProjectSort = 'date-desc' | 'date-asc' | 'title' | 'family';
+/** Les documents relus, par famille puis par identifiant. */
+export type RmProjectDocuments = Record<string, Record<string, unknown>>;
+/** « 1 ressource », « 3 ressources ». */
+export declare function rmProjectCount(count: number, lang?: RmProjectLang): string;
+/**
+ * La ligne qui situe un projet : qui le tient, s'il est partage, combien il
+ * contient. Sans compte, elle s'en passe plutot que d'afficher zero.
+ */
+export declare function rmProjectSummary(project: RmProject, lang?: RmProjectLang): string;
+/**
+ * Les epingles d'abord, quel que soit leur proprietaire, puis les miens, puis
+ * ceux qu'on m'a partages. Un groupe vide n'est pas rendu ; l'ordre recu tient
+ * dans chaque groupe.
+ */
+export declare function rmProjectGroups(list: RmProject[], lang?: RmProjectLang): RmProjectGroup[];
+/**
+ * La requete qui relit les documents d'une famille. Un appel par famille : la
+ * requete porte sur l'index du type, c'est le seul lien entre un element range
+ * et sa donnee.
+ */
+export declare function rmProjectQuery(kind: RmProjectKind, ids: string[]): Record<string, unknown>;
+/** Les hits d'une reponse, ranges par `_id`. */
+export declare function rmProjectIndexHits(hits: Array<{
+    _id: string;
+    _source?: any;
+}>): Record<string, unknown>;
+/**
+ * Relit les documents de tous les elements, une requete par famille, en
+ * parallele. `search` est l'appel Elasticsearch de l'app (son proxy). Une
+ * famille en echec reste vide : ses lignes sortent sans titre, la page tient.
+ */
+export declare function rmProjectHydrate(items: RmProjectItem[], kinds: RmProjectKind[], search: (index: string, body: Record<string, unknown>) => Promise<{
+    hits?: {
+        hits?: Array<{
+            _id: string;
+            _source?: any;
+        }>;
+    };
+} | null | undefined>): Promise<RmProjectDocuments>;
+/**
+ * Les lignes du projet, dans l'ordre des familles de l'app. Un element dont
+ * la famille n'est pas decrite sort quand meme (`known: false`), sous son
+ * type : mieux vaut le montrer que le faire disparaitre du projet. A l'app de
+ * le filtrer si elle ne veut que les siennes.
+ */
+export declare function rmProjectRows(items: RmProjectItem[], documents: RmProjectDocuments, kinds: RmProjectKind[], lang?: RmProjectLang): RmProjectResource[];
+/** Les familles presentes, avec leur compte, dans l'ordre des lignes. */
+export declare function rmProjectFamilies(rows: RmProjectResource[]): Array<{
+    type: string;
+    label: string;
+    icon: string;
+    count: number;
+}>;
+export interface RmProjectFilter {
+    search?: string;
+    /** Famille retenue, `all` ou absent pour toutes. */
+    family?: string;
+    onlyCommented?: boolean;
+    sort?: RmProjectSort;
+}
+/**
+ * Filtre et trie en memoire : un projet tient quelques centaines d'elements,
+ * deja relus. La recherche porte sur tout ce que la ligne affiche et sur
+ * l'identifiant (un element sans document n'a plus que lui) ; chaque mot doit
+ * se trouver quelque part, casse et accents ignores.
+ */
+export declare function rmProjectFilterRows(rows: RmProjectResource[], filter: RmProjectFilter, lang?: RmProjectLang): RmProjectResource[];

package/dist/runtime/utils/projects.js

@@ -0,0 +1,123 @@
+const WORDS = {
+  fr: {
+    pinned: "\xC9pingl\xE9s",
+    mine: "Mes projets",
+    shared: "Partag\xE9s avec moi",
+    me: "Moi",
+    isShared: "Partag\xE9",
+    personal: "Personnel",
+    resource: "ressource",
+    resources: "ressources"
+  },
+  en: {
+    pinned: "Pinned",
+    mine: "My projects",
+    shared: "Shared with me",
+    me: "Me",
+    isShared: "Shared",
+    personal: "Personal",
+    resource: "resource",
+    resources: "resources"
+  }
+};
+export function rmProjectCount(count, lang = "fr") {
+  const T = WORDS[lang] ?? WORDS.fr;
+  return `${count} ${count > 1 ? T.resources : T.resource}`;
+}
+export function rmProjectSummary(project, lang = "fr") {
+  const T = WORDS[lang] ?? WORDS.fr;
+  const owner = project.mine ? T.me : project.ownerName || "";
+  const kind = project.shared ? T.isShared : T.personal;
+  const size = project.resourcesCount == null ? "" : rmProjectCount(project.resourcesCount, lang);
+  return [owner, kind, size].filter(Boolean).join(" \xB7 ");
+}
+export function rmProjectGroups(list, lang = "fr") {
+  const T = WORDS[lang] ?? WORDS.fr;
+  const groups = [
+    { key: "pinned", label: T.pinned, projects: list.filter((p) => p.pinned) },
+    { key: "mine", label: T.mine, projects: list.filter((p) => !p.pinned && p.mine) },
+    { key: "shared", label: T.shared, projects: list.filter((p) => !p.pinned && !p.mine) }
+  ];
+  return groups.filter((group) => group.projects.length);
+}
+function fold(value) {
+  return String(value ?? "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+}
+export function rmProjectQuery(kind, ids) {
+  return {
+    size: ids.length,
+    ...kind.source && { _source: kind.source },
+    query: { ids: { values: ids } }
+  };
+}
+export function rmProjectIndexHits(hits) {
+  return Object.fromEntries(hits.map((hit) => [String(hit._id), hit._source ?? {}]));
+}
+export async function rmProjectHydrate(items, kinds, search) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!kinds.some((kind) => kind.type === item.resourceType)) continue;
+    byType.set(item.resourceType, [...byType.get(item.resourceType) ?? [], item.resourceId]);
+  }
+  const out = {};
+  await Promise.all(
+    [...byType].map(async ([type, ids]) => {
+      const kind = kinds.find((k) => k.type === type);
+      out[type] = {};
+      try {
+        const response = await search(kind.index, rmProjectQuery(kind, [...new Set(ids)]));
+        out[type] = rmProjectIndexHits(response?.hits?.hits ?? []);
+      } catch {
+      }
+    })
+  );
+  return out;
+}
+export function rmProjectRows(items, documents, kinds, lang = "fr") {
+  const rank = (type) => {
+    const index = kinds.findIndex((kind) => kind.type === type);
+    return index < 0 ? kinds.length : index;
+  };
+  return [...items].sort((a, b) => rank(a.resourceType) - rank(b.resourceType)).map((item) => {
+    const kind = kinds.find((k) => k.type === item.resourceType);
+    const source = documents[item.resourceType]?.[item.resourceId];
+    return {
+      id: item.resourceId,
+      type: item.resourceType,
+      title: kind && source ? kind.title(source, lang) : kind?.titleFromId?.(item.resourceId) ?? "",
+      subtitle: kind && source ? kind.subtitle?.(source, lang) ?? "" : "",
+      path: kind && source ? kind.path?.(source, item.resourceId) ?? "" : "",
+      family: kind ? kind.label[lang] : item.resourceType,
+      section: kind?.section?.[lang],
+      icon: kind?.icon ?? "Question",
+      createdAt: item.createdAt,
+      comments: item.commentsCount ?? 0,
+      known: !!kind,
+      source
+    };
+  });
+}
+export function rmProjectFamilies(rows) {
+  const out = [];
+  for (const row of rows) {
+    const found = out.find((family) => family.type === row.type);
+    if (found) found.count++;
+    else out.push({ type: row.type, label: row.family, icon: row.icon, count: 1 });
+  }
+  return out;
+}
+export function rmProjectFilterRows(rows, filter, lang = "fr") {
+  const words = fold(filter.search).split(/\s+/).filter(Boolean);
+  const family = filter.family && filter.family !== "all" ? filter.family : "";
+  const order = rmProjectFamilies(rows).map((f) => f.type);
+  const list = rows.filter((row) => !family || row.type === family).filter((row) => !filter.onlyCommented || (row.comments ?? 0) > 0).filter((row) => !words.length || words.every((word) => fold([row.title, row.subtitle, row.family, row.section, row.id].join(" ")).includes(word)));
+  const byDate = (a, b) => String(a.createdAt ?? "").localeCompare(String(b.createdAt ?? ""));
+  const byTitle = (a, b) => (a.title || a.id).localeCompare(b.title || b.id, lang);
+  const sort = filter.sort ?? "date-desc";
+  return [...list].sort((a, b) => {
+    if (sort === "date-asc") return byDate(a, b);
+    if (sort === "title") return byTitle(a, b);
+    if (sort === "family") return order.indexOf(a.type) - order.indexOf(b.type) || byTitle(a, b);
+    return byDate(b, a);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/romulus",
-  "version": "0.1.231",
+  "version": "0.1.233",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",