@tekkare/romulus 0.1.231 → 0.1.232

package/dist/runtime/components/ProjectRenameDialog.vue

@@ -0,0 +1,67 @@
+<!--
+  RmProjectRenameDialog - renommer un projet.
+
+  Un champ dans une modale plutot qu'un titre editable sur place : pour que
+  l'enregistrement et l'echec aient ou se dire. Le champ repart du titre
+  courant a chaque ouverture ; Entree enregistre.
+-->
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+
+const props = withDefaults(
+  defineProps<{
+    modelValue: boolean
+    /** Titre actuel du projet. */
+    title: string
+    loading?: boolean
+    error?: string
+    lang?: 'fr' | 'en'
+  }>(),
+  { loading: false, error: '', lang: 'fr' },
+)
+
+const emit = defineEmits<{
+  'update:modelValue': [value: boolean]
+  'save': [title: string]
+}>()
+
+const WORDS = {
+  fr: { heading: 'Renommer le projet', name: 'Nom du projet', cancel: 'Annuler', save: 'Enregistrer' },
+  en: { heading: 'Rename the project', name: 'Project name', cancel: 'Cancel', save: 'Save' },
+}
+const T = computed(() => WORDS[props.lang] ?? WORDS.fr)
+
+const draft = ref('')
+watch(() => props.modelValue, (open) => {
+  if (open) draft.value = props.title
+}, { immediate: true })
+
+const open = computed({
+  get: () => props.modelValue,
+  set: (value: boolean) => emit('update:modelValue', value),
+})
+
+function save() {
+  const title = draft.value.trim()
+  if (!title || props.loading) return
+  emit('save', title)
+}
+</script>
+
+<template>
+  <RmModal v-model="open" size="sm" :label="T.heading">
+    <template #header>
+      <h2 class="rm-project-dialog__title">{{ T.heading }}</h2>
+    </template>
+    <RmInput v-model="draft" :label="T.name" @keyup.enter="save" />
+    <p v-if="error" class="rm-project-dialog__error">{{ error }}</p>
+    <template #footer>
+      <RmButton variant="tertiary" @click="open = false">{{ T.cancel }}</RmButton>
+      <RmButton variant="primary" :loading="loading" :disabled="!draft.trim()" @click="save">{{ T.save }}</RmButton>
+    </template>
+  </RmModal>
+</template>
+
+<style scoped>
+.rm-project-dialog__title{font-size:var(--font-18);font-weight:var(--weight-bold);margin:0}.rm-project-dialog__error{color:var(--color-danger);font-size:var(--font-13);margin:8px 0 0}
+</style>

package/dist/runtime/components/ProjectResources.vue

@@ -0,0 +1,258 @@
+<!--
+  RmProjectResources - l'onglet « Ressources » d'un projet.
+
+  Une ligne par element range, toutes familles confondues : icone de la
+  famille, titre (un vrai lien : Ctrl/Cmd-clic ouvre la fiche dans un onglet,
+  le clic simple rend `open` pour un apercu sur place), sous-titre, d'ou vient
+  l'element et quand il est entre, puis Commenter et Retirer.
+
+  Recherche, puces de famille, filtre « commentees » et tri se font en
+  memoire (cf. rmProjectFilterRows) : un projet tient quelques centaines
+  d'elements, deja relus. L'app donne les lignes (cf. rmProjectRows), avec
+  `path` deja prefixe de la langue.
+
+  Un element dont le document a disparu de l'index reste liste sous son
+  identifiant : mieux vaut le montrer, et laisser le retirer, que le faire
+  disparaitre en silence.
+-->
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+import {
+  rmProjectCount,
+  rmProjectFamilies,
+  rmProjectFilterRows,
+  type RmProjectResource,
+  type RmProjectSort,
+} from '../utils/projects'
+
+const props = withDefaults(
+  defineProps<{
+    rows: RmProjectResource[]
+    loading?: boolean
+    failed?: boolean
+    /** `type-id` de la ligne en cours de retrait. */
+    removing?: string
+    /** Texte de l'etat vide : ou trouver le bouton Projet dans cette app. */
+    emptyText?: string
+    /** Id de l'element a la barre de filtres collante. Vide : pas de barre collante. */
+    stickyTo?: string | null
+    lang?: 'fr' | 'en'
+  }>(),
+  { loading: false, failed: false, removing: '', emptyText: '', stickyTo: 'rm_page_header', lang: 'fr' },
+)
+
+const emit = defineEmits<{
+  open: [row: RmProjectResource]
+  comment: [row: RmProjectResource]
+  remove: [row: RmProjectResource]
+}>()
+
+const WORDS = {
+  fr: {
+    search: 'Rechercher une ressource', sortBy: 'Trier par', comments: 'Annotations', withComments: 'Contient des commentaires',
+    loading: 'Chargement', failedTitle: 'Projet indisponible', failedText: 'Le service des projets n\'a pas répondu.',
+    emptyTitle: 'Ce projet est vide', emptyText: 'Parcourez les pages et utilisez le bouton Projet d\'une carte pour la ranger ici.',
+    families: 'Filtrer par famille', all: 'Toutes', resources: 'Ressources', noMatch: 'Aucune ressource ne correspond à ces filtres.',
+    comment: 'Commenter', commentsN: (n: number) => `Commentaires (${n})`, remove: 'Retirer du projet',
+    unknown: (id: string) => `Élément inconnu (id ${id})`, source: 'Source', added: 'Ajouté le',
+    filed: (n: number) => `${rmProjectCount(n, 'fr')} ${n > 1 ? 'rangées' : 'rangée'} dans le projet.`,
+    shown: (s: number, n: number) => `${s} ${s > 1 ? 'affichées' : 'affichée'} sur ${rmProjectCount(n, 'fr')}.`,
+    sorts: { 'date-desc': 'Ajout, plus récent d\'abord', 'date-asc': 'Ajout, plus ancien d\'abord', 'title': 'Titre', 'family': 'Famille' },
+  },
+  en: {
+    search: 'Search a resource', sortBy: 'Sort by', comments: 'Comments', withComments: 'With comments',
+    loading: 'Loading', failedTitle: 'Project unavailable', failedText: 'The project service did not answer.',
+    emptyTitle: 'Nothing in this project yet', emptyText: 'Browse the pages and use the Project button on a card to file it here.',
+    families: 'Filter by family', all: 'All', resources: 'Resources', noMatch: 'No resource matches these filters.',
+    comment: 'Comment', commentsN: (n: number) => `Comments (${n})`, remove: 'Remove from the project',
+    unknown: (id: string) => `Unknown item (id ${id})`, source: 'Source', added: 'Added on',
+    filed: (n: number) => `${rmProjectCount(n, 'en')} filed in the project.`,
+    shown: (s: number, n: number) => `${s} shown out of ${rmProjectCount(n, 'en')}.`,
+    sorts: { 'date-desc': 'Newest first', 'date-asc': 'Oldest first', 'title': 'Title', 'family': 'Family' },
+  },
+}
+const T = computed(() => WORDS[props.lang] ?? WORDS.fr)
+
+const search = ref('')
+const family = ref('all')
+const onlyCommented = ref(false)
+const sort = ref<RmProjectSort>('date-desc')
+
+/** RmDropdownSelect ne porte que des libelles : on traduit dans les deux sens. */
+const sortLabels = computed(() => Object.values(T.value.sorts))
+const sortLabel = computed({
+  get: () => T.value.sorts[sort.value],
+  set: (label: string) => {
+    const found = (Object.keys(T.value.sorts) as RmProjectSort[]).find(key => T.value.sorts[key] === label)
+    if (found) sort.value = found
+  },
+})
+
+function clearFilters() {
+  search.value = ''
+  family.value = 'all'
+  onlyCommented.value = false
+}
+
+const families = computed(() => rmProjectFamilies(props.rows))
+const shown = computed(() => rmProjectFilterRows(props.rows, {
+  search: search.value,
+  family: family.value,
+  onlyCommented: onlyCommented.value,
+  sort: sort.value,
+}, props.lang))
+
+const context = computed(() => {
+  const total = props.rows.length
+  return shown.value.length === total ? T.value.filed(total) : T.value.shown(shown.value.length, total)
+})
+
+function formatDate(value?: string) {
+  const date = new Date(value ?? '')
+  if (Number.isNaN(date.getTime())) return ''
+  return date.toLocaleDateString(props.lang === 'en' ? 'en-GB' : 'fr-FR', { day: 'numeric', month: 'long', year: 'numeric' })
+}
+
+function meta(row: RmProjectResource) {
+  return [
+    row.section ? `${T.value.source} : ${row.section}` : '',
+    row.createdAt ? `${T.value.added} ${formatDate(row.createdAt)}` : '',
+  ].filter(Boolean).join(' · ')
+}
+
+function commentLabel(row: RmProjectResource) {
+  return row.comments ? T.value.commentsN(row.comments) : T.value.comment
+}
+
+/** Le clic simple ouvre l'apercu ; les autres gardent le comportement du lien. */
+function onTitle(event: MouseEvent, row: RmProjectResource) {
+  if (event.metaKey || event.ctrlKey || event.shiftKey || event.button !== 0) return
+  event.preventDefault()
+  emit('open', row)
+}
+</script>
+
+<template>
+  <div class="rm-project-res">
+    <RmFilterBar
+      :filters-amount="onlyCommented ? 1 : 0"
+      :lang="lang"
+      :sticky-to="stickyTo"
+      @clear-filters="clearFilters"
+    >
+      <template #Search>
+        <div class="rm-project-res__search">
+          <RmSearchBar v-model="search" :have-advanced="false" :placeholder="T.search" />
+        </div>
+      </template>
+      <template #Filters>
+        <RmDropdownSelect
+          v-model="sortLabel"
+          :label="T.sortBy"
+          :options="sortLabels"
+          :search="false"
+          sort-icon
+          close-on-click
+          :lang="lang"
+        />
+        <RmCheckbox v-model="onlyCommented" :field-label="T.comments" :label="T.withComments" />
+      </template>
+    </RmFilterBar>
+
+    <RmLoadingState v-if="loading && !rows.length" spinner :label="T.loading" />
+
+    <RmErrorState v-else-if="failed" icon="CloudWarning" :title="T.failedTitle" :text="T.failedText" action-label="" />
+
+    <RmEmptyState v-else-if="!rows.length" icon="FolderSimplePlus" :title="T.emptyTitle" :text="emptyText || T.emptyText" />
+
+    <template v-else>
+      <div class="rm-project-res__chips" role="group" :aria-label="T.families">
+        <RmPill :label="T.all" :active="family === 'all'" @click="family = 'all'">
+          <span class="rm-project-res__chip-count">{{ rows.length }}</span>
+        </RmPill>
+        <RmPill
+          v-for="chip in families"
+          :key="chip.type"
+          :label="chip.label"
+          :active="family === chip.type"
+          @click="family = chip.type"
+        >
+          <span class="rm-project-res__chip-count">{{ chip.count }}</span>
+        </RmPill>
+      </div>
+
+      <RmCard padding="lg">
+        <div class="rm-project-res__head">
+          <h2 class="rm-project-res__title">{{ T.resources }}</h2>
+          <p class="rm-project-res__context">{{ context }}</p>
+        </div>
+
+        <ol v-if="shown.length" class="rm-project-res__list">
+          <li v-for="row in shown" :key="`${row.type}-${row.id}`" class="rm-project-res__item">
+            <span class="rm-project-res__icon" aria-hidden="true">
+              <RmIcon :name="row.icon" :size="17" />
+            </span>
+
+            <div class="rm-project-res__text">
+              <p class="rm-project-res__item-title">
+                <a v-if="row.path" :href="row.path" @click="onTitle($event, row)">{{ row.title || T.unknown(row.id) }}</a>
+                <span v-else>{{ row.title || T.unknown(row.id) }}</span>
+                <button
+                  v-if="row.comments"
+                  type="button"
+                  class="rm-project-res__comments"
+                  :aria-label="commentLabel(row)"
+                  @click="emit('comment', row)"
+                >
+                  <RmIcon name="ChatCircle" :size="12" />
+                  {{ row.comments }}
+                </button>
+              </p>
+              <p v-if="row.subtitle" class="rm-project-res__sub">{{ row.subtitle }}</p>
+              <p v-if="meta(row)" class="rm-project-res__meta">{{ meta(row) }}</p>
+            </div>
+
+            <RmBadge variant="info" class="rm-project-res__family">{{ row.family }}</RmBadge>
+
+            <!-- Des icones seules : la bulle dit le geste avant le clic. Elle
+                 sort a gauche, la carte couperait une bulle centree. -->
+            <div class="rm-project-res__actions">
+              <RmTooltip :text="commentLabel(row)" dir="left">
+                <RmButton
+                  variant="tertiary"
+                  size="sm"
+                  icon-only
+                  ghost
+                  prefix-icon="ChatCircle"
+                  :aria-label="commentLabel(row)"
+                  @click="emit('comment', row)"
+                />
+              </RmTooltip>
+              <RmTooltip :text="T.remove" dir="left">
+                <RmButton
+                  variant="tertiary"
+                  size="sm"
+                  icon-only
+                  ghost
+                  prefix-icon="Trash"
+                  :loading="removing === `${row.type}-${row.id}`"
+                  :aria-label="T.remove"
+                  @click="emit('remove', row)"
+                />
+              </RmTooltip>
+            </div>
+          </li>
+        </ol>
+
+        <p v-else class="rm-project-res__none">
+          <RmIcon name="FunnelX" :size="16" />
+          {{ T.noMatch }}
+        </p>
+      </RmCard>
+    </template>
+  </div>
+</template>
+
+<style scoped>
+.rm-project-res{display:flex;flex-direction:column;gap:16px}.rm-project-res__search{flex:0 1 360px;min-width:160px}.rm-project-res__chips{display:flex;flex-wrap:wrap;gap:6px}.rm-project-res__chip-count{background:var(--bg-surface-3);border-radius:999px;color:var(--text-secondary);font-size:10px;font-weight:700;padding:1px 6px}.toolbar-pill--active .rm-project-res__chip-count{background:hsla(0,0%,100%,.25);color:var(--color-text-inverse)}.rm-project-res__head{display:flex;flex-direction:column;gap:4px;margin-bottom:8px}.rm-project-res__title{color:var(--text-primary);font-size:15px;font-weight:var(--weight-bold);margin:0}.rm-project-res__context{color:var(--text-muted);font-size:12px;margin:0}.rm-project-res__list{display:flex;flex-direction:column;list-style:none;margin:0;padding:0}.rm-project-res__item{align-items:center;border-bottom:1px solid var(--border-soft,var(--border-default));display:flex;gap:12px;padding:10px 0}.rm-project-res__item:last-child{border-bottom:none}.rm-project-res__icon{align-items:center;background:var(--bg-surface-3);border-radius:var(--radius-lg,8px);color:var(--text-secondary);display:flex;flex:none;height:34px;justify-content:center;width:34px}.rm-project-res__text{flex:1;min-width:0}.rm-project-res__item-title{align-items:center;color:var(--text-primary);display:flex;font-size:13px;font-weight:var(--weight-semibold);gap:6px;margin:0}.rm-project-res__item-title a{color:var(--color-primary);text-decoration:underline;text-underline-offset:2px}.rm-project-res__comments{align-items:center;background:var(--bg-surface-3);border:none;border-radius:999px;color:var(--text-secondary);cursor:pointer;display:inline-flex;font:inherit;font-size:11px;gap:3px;padding:1px 6px}.rm-project-res__sub{color:var(--text-secondary);font-size:12px;margin:2px 0 0}.rm-project-res__meta{color:var(--text-muted);font-size:11px;margin:2px 0 0}.rm-project-res__family{flex:none}.rm-project-res__actions{align-items:center;display:flex;flex:none;gap:2px}.rm-project-res__none{align-items:center;color:var(--text-secondary);display:flex;font-size:13px;gap:6px;margin:8px 0}
+</style>

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.232",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",