@nocode-factory/sanity-kit 2.54.0 → 2.58.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. package/README.md +61 -6
  2. package/bin/item-types.mjs +131 -0
  3. package/bin/ncf-kit.mjs +97 -0
  4. package/dist/index.d.ts +48 -4
  5. package/dist/index.js +7222 -6916
  6. package/dist/index.js.map +1 -1
  7. package/dist/inherited-DZvM35P6.js +101 -0
  8. package/dist/inherited-DZvM35P6.js.map +1 -0
  9. package/dist/protocol-Bl7Yj2Ro.js +31 -0
  10. package/dist/protocol-Bl7Yj2Ro.js.map +1 -0
  11. package/dist/web-edit.d.ts +192 -0
  12. package/dist/web-edit.js +144 -0
  13. package/dist/web-edit.js.map +1 -0
  14. package/dist/web-editing.d.ts +51 -0
  15. package/dist/web-editing.js +693 -0
  16. package/dist/web-editing.js.map +1 -0
  17. package/package.json +22 -2
  18. package/scripts/use-client.mjs +1 -1
  19. package/src/form/AssetSourceBrowser.tsx +68 -39
  20. package/src/hooks/useCollection.ts +19 -3
  21. package/src/index.ts +3 -2
  22. package/src/lib/collectionQuery.ts +10 -2
  23. package/src/structure/collections.tsx +35 -5
  24. package/src/tools/collections/CollectionTable.tsx +295 -89
  25. package/src/tools/collections/CollectionToolbar.tsx +53 -4
  26. package/src/ui/PreviewEditBridge.tsx +74 -0
  27. package/src/version.ts +1 -1
  28. package/src/web/edit/ImageReplaceLayer.tsx +174 -0
  29. package/src/web/edit/InlineTextEditor.tsx +365 -0
  30. package/src/web/edit/InlineTextOverlay.tsx +43 -0
  31. package/src/web/edit/PreviewEditing.tsx +191 -0
  32. package/src/web/edit/index.ts +18 -0
  33. package/src/web/edit/inherited.ts +174 -0
  34. package/src/web/edit/labels.ts +37 -0
  35. package/src/web/edit/protocol.ts +47 -0
  36. package/src/web/edit/store.ts +98 -0
  37. package/src/web/edit/targets.ts +186 -0
  38. package/src/web/editing.ts +18 -0
package/README.md CHANGED
@@ -35,7 +35,8 @@ reste d'avant la 2.0.0 (figé en 1.8.0) : le retirer.
35
35
  | Site, rendu des sections | `applyDefaults(section, defaults, isDraft ? reattributeTo(source, section._key) : undefined)` ; défauts lus avec `componentDefaultsQuery(types, projection)` |
36
36
  | Site, design system | page `/design-system/composant?type=<nom>` (rendu réel d'un composant, voir le starter) |
37
37
  | Studio, redirections | structure : `redirectsStructure(S, {icon})` (sous-dossiers Manual / Slug changes / Languages) ; type `redirect` : `const c = redirectConflicts({siteRoutes, i18n: {defaultLocale}})`, `from` → `rule.custom(c.from)`, `to` → `rule.custom(c.to)` (publication refusée en cas de conflit) |
38
- | Studio, collections | structure : vue table (tri, filtres par colonne, export CSV) — `.child(ncfCollectionTable(S, options, type))` sur une entrée de collection, ou `...ncfCollections(S, context, options)` pour la découverte auto |
38
+ | Studio, collections | structure : vue table (tri, recherche, export CSV) + switch vue liste — `.child(ncfCollectionTable(S, options, type))` sur une entrée de collection, ou `...ncfCollections(S, context, options)` pour la découverte auto |
39
+ | Site, édition sur place (aperçu) | `<VisualEditing components={ncfOverlayComponents} …/>` + `<NcfPreviewEditing labels={…} />` (`/web/editing`) ; requêtes en brouillon : `annotateImageEditTargets(data, sourceMap, {studioUrl})` ; sections : `withPreviewEditTargets(reattributeTo(…), source, key, collected, {studioUrl})`, `rekeyOwnImageTargets`, `<script {...inheritedEditScriptProps(entry)} />` ; images : `imageEditAttributes(image)`, `imageAlt(image)` (`/web/edit`). Voir « Édition sur place dans l'aperçu ». |
39
40
 
40
41
  Puis, depuis `studio/` :
41
42
 
@@ -49,12 +50,16 @@ Zéro ✖ = projet complet. Sortie 1 sinon (utilisable en CI).
49
50
 
50
51
  Cliquer une collection dans l'onglet **Structure** ouvre une **table** plutôt que
51
52
  la liste native : une colonne par champ du CMS (texte, nombre, booléen, date et
52
- **références** résolues en titre), ajout/masquage des colonnes, **tri** et
53
- **filtre** par colonne, et **export CSV** de la vue courante. Lecture seule :
54
- cliquer une ligne ouvre le document dans l'éditeur. Les colonnes sont tirées du
55
- schéma — rien à déclarer.
53
+ **références** résolues en titre), ajout/masquage des colonnes, colonnes
54
+ **redimensionnables** (poignée) et **déplaçables** (glisser l'en-tête), **tri** par
55
+ colonne, **recherche globale**, **export CSV** de la vue courante et un bouton
56
+ **« + »** de création. Un **switch Liste / Table** en haut bascule entre la table
57
+ dense et une **vue liste façon Sanity** (vignette du type, titre, chemin et pastille
58
+ de statut publié/brouillon). Lecture seule sur les lignes : cliquer une ligne ouvre
59
+ le document **en volet enfant** (à droite ; les volets précédents se réduisent sans
60
+ se fermer). Les colonnes sont tirées du schéma — rien à déclarer.
56
61
 
57
- Deux façons de la brancher dans le résolveur de structure :
62
+ Trois façons de la brancher dans le résolveur de structure :
58
63
 
59
64
  ```ts
60
65
  import {ncfCollections, ncfCollectionTable} from '@nocode-factory/sanity-kit'
@@ -68,6 +73,20 @@ structure: (S, context) =>
68
73
 
69
74
  // 2. Au cas par cas : la table comme vue d'une entrée de collection existante.
70
75
  S.listItem().title('Articles').child(ncfCollectionTable(S, ncfOptions, 'article'))
76
+
77
+ // 3. Au NIVEAU FEUILLE : la table remplace la `documentList` la plus granulaire
78
+ // (une langue, une catégorie…) sans mélanger le reste. `filter`/`params` la
79
+ // restreignent, `newTemplate` garde la création pré-taguée, `id` reste unique
80
+ // quand un même type a plusieurs tables.
81
+ S.listItem().title('Français').child(
82
+ ncfCollectionTable(S, ncfOptions, 'newsArticle', {
83
+ id: 'ncf-col-newsArticle-fr',
84
+ title: 'News (Français)',
85
+ filter: 'language == $lang',
86
+ params: {lang: 'fr'},
87
+ newTemplate: 'newsArticle-fr',
88
+ }),
89
+ )
71
90
  ```
72
91
 
73
92
  Sélection des types : par défaut tous les types de documents hors pages,
@@ -149,6 +168,42 @@ Les outils de schéma sont aussi dans l'entrée `@nocode-factory/sanity-kit/sche
149
168
 
150
169
  `npx ncf-kit doctor` vérifie chaque branchement.
151
170
 
171
+ ## Édition sur place dans l'aperçu (Presentation)
172
+
173
+ Dans l'aperçu du Studio, en **Edit mode** :
174
+
175
+ - **Texte** (champ chaîne, ligne ou passage en italique d'un titre en texte riche) : crayon
176
+ au survol ; au clic, un champ de saisie prend la place exacte du texte, dans sa
177
+ typographie. Entrée ou clic ailleurs = enregistré dans le **brouillon** (patch du seul
178
+ champ), Échap = annulé. Rien n'est publié.
179
+ - **Texte hérité** des valeurs par défaut du composant : l'éditeur part de la valeur par
180
+ défaut EXACTE (jamais du texte affiché, que le composant met en forme). Une liste
181
+ héritée (lignes d'un titre, titre en texte riche sans lien) est recopiée dans la page au
182
+ premier enregistrement ; la valeur par défaut ne change jamais.
183
+ - **Image** (alt rempli ou non, même sous un dégradé ou un titre en plein cadre) :
184
+ « Replace this image » au survol ; au clic, le Studio ouvre la médiathèque en quasi plein
185
+ écran (masonry, dossiers, recherche). Cadrage et point focal retirés.
186
+ - **Browse mode** : un clic suit les liens, comme sur le site. Interrupteur du kit en bas
187
+ à gauche de l'aperçu (mémorisé) ; un projet peut brancher le sien :
188
+ `<NcfPreviewEditing editMode={() => …} />`.
189
+
190
+ **Dépendances du site** : `@sanity/visual-editing` et `@sanity/mutate` déclarés dans
191
+ `web/package.json`, à la MÊME version que celle de next-sanity, puis `npm dedupe` : deux
192
+ copies = deux connexions au Studio, l'éditeur enregistrerait dans le vide. `doctor` le
193
+ vérifie.
194
+
195
+ Libellés anglais par défaut : passer ceux du projet (`labels`). Couleurs : variables CSS
196
+ `--ncf-edit-accent`, `--ncf-edit-chip`, `--ncf-edit-font`.
197
+
198
+ Le pont côté Studio (message de l'aperçu, médiathèque) est monté par le plugin : rien à
199
+ brancher. Seules les origines des environnements du kit (`environments`, `previewUrl`)
200
+ sont écoutées, depuis une fenêtre affichée par le Studio.
201
+
202
+ **Éléments de liste sans `_type`** (écrits par script) : le site les affiche, mais le
203
+ formulaire du Studio plante en les ouvrant et l'aperçu ne peut pas les éditer.
204
+ `npx ncf-kit item-types` les liste (sortie 1), `--apply` les corrige par patch ciblé ;
205
+ `doctor` le vérifie.
206
+
152
207
  ## Test prod / préprod (bloquant)
153
208
 
154
209
  Le kit livre le test qui garantit que la production n'affiche **jamais** de brouillon
@@ -0,0 +1,131 @@
1
+ // ÉLÉMENTS DE LISTE SANS `_type` : tout élément d'une liste d'objets (cartes,
2
+ // lieux, chiffres clés, lignes de tableau...) porte le `_type` que le schéma
3
+ // déclare pour la liste. Le Studio le pose toujours lui-même ; un élément écrit
4
+ // par SCRIPT sans `_type` passe inaperçu sur le site (qui ne lit que les champs),
5
+ // mais casse l'édition :
6
+ // - formulaire : « Could not render the document editor » dès qu'on ouvre
7
+ // l'élément ;
8
+ // - Presentation : l'élément n'est plus relié au schéma (pas d'édition sur place).
9
+ //
10
+ // Module pur (sans dépendance) : parcourt un document avec le schéma EXTRAIT
11
+ // (`sanity schema extract`, format TypeGen) et liste les éléments sans `_type`,
12
+ // avec le `_type` attendu quand il n'y a pas d'ambiguïté. Utilisé par
13
+ // `npx ncf-kit item-types` et par `doctor` ; testé (test/itemTypes.test.ts).
14
+
15
+ const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v)
16
+
17
+ export function createTypeIndex(schema) {
18
+ const byName = new Map()
19
+ for (const entry of schema) byName.set(entry.name, entry.type === 'document' ? {type: 'object', attributes: entry.attributes} : entry.value)
20
+
21
+ // Résout un nœud jusqu'à un objet / tableau / union / scalaire (références
22
+ // « inline » et attributs hérités par `rest` fusionnés).
23
+ function resolve(node, seen = new Set()) {
24
+ if (!node) return undefined
25
+ if (node.type === 'inline' && node.name) {
26
+ if (seen.has(node.name)) return undefined
27
+ seen.add(node.name)
28
+ return resolve(byName.get(node.name), seen)
29
+ }
30
+ if (node.type === 'object' && node.rest) {
31
+ const rest = resolve(node.rest, seen)
32
+ return {type: 'object', attributes: {...(rest?.attributes ?? {}), ...(node.attributes ?? {})}}
33
+ }
34
+ return node
35
+ }
36
+
37
+ const literalType = (node) => {
38
+ const t = node?.attributes?._type?.value
39
+ return t && t.type === 'string' && typeof t.value === 'string' ? t.value : null
40
+ }
41
+
42
+ function objectMembers(arrayNode) {
43
+ const out = []
44
+ const add = (n) => {
45
+ const r = resolve(n)
46
+ if (!r) return
47
+ if (r.type === 'union') for (const m of r.of) add(m)
48
+ else if (r.type === 'object') out.push(r)
49
+ }
50
+ add(arrayNode.of)
51
+ return out
52
+ }
53
+
54
+ function pickObject(node, value) {
55
+ const r = resolve(node)
56
+ if (!r) return undefined
57
+ if (r.type === 'object') return r
58
+ if (r.type === 'union') {
59
+ const members = r.of.map((m) => resolve(m)).filter((m) => m?.type === 'object')
60
+ return members.find((m) => literalType(m) === value._type) ?? (members.length === 1 ? members[0] : undefined)
61
+ }
62
+ return undefined
63
+ }
64
+ function pickArray(node) {
65
+ const r = resolve(node)
66
+ if (!r) return undefined
67
+ if (r.type === 'array') return r
68
+ if (r.type === 'union') return r.of.map((m) => resolve(m)).find((m) => m?.type === 'array')
69
+ return undefined
70
+ }
71
+
72
+ function walk(value, node, path, out) {
73
+ if (Array.isArray(value)) {
74
+ const arr = pickArray(node)
75
+ if (!arr) return
76
+ const members = objectMembers(arr)
77
+ value.forEach((item, index) => {
78
+ if (!isObj(item)) return
79
+ const key = typeof item._key === 'string' ? item._key : null
80
+ const itemPath = key ? `${path}[_key=="${key}"]` : `${path}[${index}]`
81
+ let member
82
+ if (typeof item._type === 'string') member = members.find((m) => literalType(m) === item._type)
83
+ else if (members.length > 0) {
84
+ // Un élément sans `_ref` n'est pas une référence (liste « carte OU carte liée »).
85
+ const candidates = members.filter((m) => (literalType(m) === 'reference') === (typeof item._ref === 'string'))
86
+ const expected = candidates.length === 1 ? literalType(candidates[0]) : null
87
+ out.push({path: itemPath, expected, ...(key ? {} : {noKey: true})})
88
+ member = candidates.length === 1 ? candidates[0] : undefined
89
+ }
90
+ if (member) walkObject(item, member, itemPath, out)
91
+ })
92
+ return
93
+ }
94
+ if (!isObj(value)) return
95
+ const obj = pickObject(node, value)
96
+ if (obj) walkObject(value, obj, path, out)
97
+ }
98
+
99
+ function walkObject(value, node, path, out) {
100
+ for (const [k, child] of Object.entries(value)) {
101
+ if (k.startsWith('_')) continue
102
+ const attr = node.attributes?.[k]
103
+ if (attr) walk(child, attr.value, path ? `${path}.${k}` : k, out)
104
+ }
105
+ }
106
+
107
+ /** Éléments de liste sans `_type` d'un document : [{path, expected, noKey?}]. */
108
+ function missingTypes(doc) {
109
+ const root = byName.get(String(doc._type))
110
+ if (!root) return []
111
+ const out = []
112
+ walkObject(doc, resolve(root) ?? root, '', out)
113
+ return out
114
+ }
115
+
116
+ return {missingTypes}
117
+ }
118
+
119
+ /**
120
+ * Patch CIBLÉ d'un document : `set` du seul `_type` de chaque élément (et d'un
121
+ * `_key` quand il manque aussi), verrouillé sur la révision lue. Null si rien à faire.
122
+ */
123
+ export function itemTypesPatch(doc, missing, newKey) {
124
+ const set = {}
125
+ for (const m of missing) {
126
+ if (!m.expected) continue
127
+ set[`${m.path}._type`] = m.expected
128
+ if (m.noKey) set[`${m.path}._key`] = newKey()
129
+ }
130
+ return Object.keys(set).length ? {patch: {id: doc._id, ifRevisionID: doc._rev, set}} : null
131
+ }
package/bin/ncf-kit.mjs CHANGED
@@ -14,6 +14,8 @@
14
14
  import {readFileSync, writeFileSync, existsSync, readdirSync, statSync} from 'node:fs'
15
15
  import {dirname, join, resolve} from 'node:path'
16
16
  import {homedir} from 'node:os'
17
+ import {createRequire} from 'node:module'
18
+ const require_child = () => createRequire(import.meta.url)('node:child_process')
17
19
 
18
20
  const DEFAULT_ENDPOINT = 'https://dkoxgivytgsmvqmjvmjt.supabase.co/functions/v1'
19
21
  const SANITY_API = 'https://api.sanity.io'
@@ -38,6 +40,7 @@ function usage(code = 0) {
38
40
  npx ncf-kit translate-json [--from <langue>] [--apply] textes du site (messages/<langue>.json, titres du registre) traduits par IA
39
41
  npx ncf-kit translations [export] [--out <fichier>] champs « À traduire » → JSON (texte source et actuel)
40
42
  npx ncf-kit translations apply <fichier> écrit les traductions dans les brouillons
43
+ npx ncf-kit item-types [--apply] éléments de liste sans _type (écrits par script) ; --apply corrige
41
44
 
42
45
  Depuis le dossier du studio (celui de sanity.config.ts et de .env).
43
46
 
@@ -530,6 +533,27 @@ async function doctor() {
530
533
  }
531
534
 
532
535
  /* En ligne */
536
+ // Édition sur place (/web/editing) : le kit doit voir le MÊME @sanity/visual-editing que
537
+ // next-sanity. Deux copies = deux connexions au Studio : l'éditeur enregistrerait dans
538
+ // le vide (aucune erreur visible).
539
+ {
540
+ const usesEditing = (() => {
541
+ try {
542
+ const {execFileSync} = require_child()
543
+ return execFileSync('grep', ['-rl', '--include=*.tsx', '--include=*.ts', 'sanity-kit/web/editing', join(web, 'components'), join(web, 'app')], {encoding: 'utf8'}).trim().length > 0
544
+ } catch {
545
+ return false
546
+ }
547
+ })()
548
+ if (usesEditing) {
549
+ const top = read(join(web, 'node_modules', '@sanity', 'visual-editing', 'package.json'))
550
+ const nested = read(join(web, 'node_modules', 'next-sanity', 'node_modules', '@sanity', 'visual-editing', 'package.json'))
551
+ const declared = /"@sanity\/visual-editing"\s*:/.test(read(join(web, 'package.json'))) && /"@sanity\/mutate"\s*:/.test(read(join(web, 'package.json')))
552
+ if (!top || !declared) ko('Édition sur place', "le kit a besoin de @sanity/visual-editing et @sanity/mutate déclarés dans web/package.json (même version que next-sanity) : npm install @sanity/visual-editing @sanity/mutate, puis npm dedupe.")
553
+ else if (nested) ko('Édition sur place', `deux copies de @sanity/visual-editing (${JSON.parse(top).version} et ${JSON.parse(nested).version} dans next-sanity) : l'éditeur de l'aperçu enregistrerait dans le vide. Dans web/ : npm dedupe.`)
554
+ else ok('Édition sur place', `@sanity/visual-editing ${JSON.parse(top).version}, une seule copie (partagée avec next-sanity)`)
555
+ }
556
+ }
533
557
  if (!offline) {
534
558
  {
535
559
  const r = await checkDeploy({quiet: true})
@@ -577,6 +601,14 @@ async function doctor() {
577
601
  }
578
602
  }
579
603
  }
604
+ // Éléments de liste sans _type (écrits par script) : le formulaire du Studio plante
605
+ // dès qu'on les ouvre et l'aperçu ne peut pas les éditer sur place.
606
+ {
607
+ const scan = sanityToken() ? await scanItemTypes(studio, {quiet: true}) : null
608
+ if (!scan) warn('Éléments de liste typés', 'non vérifié : jeton Sanity, SANITY_STUDIO_PROJECT_ID ou `sanity schema extract` indisponible.')
609
+ else if (scan.count) ko('Éléments de liste typés', `${scan.count} élément(s) de liste sans _type dans ${scan.todo.length} document(s) (écrits par script) : le formulaire du Studio plante en les ouvrant (« Could not render the document editor »). npx ncf-kit item-types pour la liste, --apply pour corriger.`)
610
+ else ok('Éléments de liste typés', `tous les éléments de liste ont leur _type (${scan.docs} documents)`)
611
+ }
580
612
  // Purge du cache à la publication : webhook Sanity vers la PRODUCTION
581
613
  // (/api/revalidate), qui relaie à la préprod. Sans lui, rien ne se met à jour
582
614
  // sur le site avant le prochain build.
@@ -671,6 +703,69 @@ function patchPath(doc, path) {
671
703
  return out
672
704
  }
673
705
 
706
+ /**
707
+ * Éléments de liste sans `_type` (bin/item-types.mjs) dans TOUS les documents
708
+ * (brouillons et versions compris). Schéma extrait par `sanity schema extract`
709
+ * dans node_modules/.cache (jamais versionné). Renvoie null si impossible.
710
+ */
711
+ async function scanItemTypes(dir, {quiet = false} = {}) {
712
+ const env = {...parseEnv(read(join(dir, '.env'))), ...parseEnv(read(join(dir, '.env.production.local')))}
713
+ const projectId = env.SANITY_STUDIO_PROJECT_ID ?? process.env.SANITY_STUDIO_PROJECT_ID
714
+ const dataset = flag('dataset') ?? env.SANITY_STUDIO_DATASET ?? process.env.SANITY_STUDIO_DATASET ?? 'production'
715
+ const token = sanityToken()
716
+ if (!projectId || !token) return null
717
+ const {spawnSync} = await import('node:child_process')
718
+ const {mkdirSync} = await import('node:fs')
719
+ const rel = join('node_modules', '.cache', 'ncf-kit', 'schema.json')
720
+ mkdirSync(join(dir, dirname(rel)), {recursive: true})
721
+ const extract = spawnSync('npx', ['--no-install', 'sanity', 'schema', 'extract', '--force', '--path', rel], {cwd: dir, encoding: 'utf8', stdio: quiet ? 'pipe' : ['ignore', 'ignore', 'inherit']})
722
+ if (extract.status !== 0 || !existsSync(join(dir, rel))) return null
723
+ const {createTypeIndex} = await import('./item-types.mjs')
724
+ const {missingTypes} = createTypeIndex(JSON.parse(readFileSync(join(dir, rel), 'utf8')))
725
+ const api = `https://${projectId}.api.sanity.io/v2025-02-19/data`
726
+ const url = new URL(`${api}/query/${dataset}`)
727
+ url.searchParams.set('query', '*[!(_type match "system.*") && !(_type match "sanity.*") && !(_id in path("_.**"))]')
728
+ url.searchParams.set('perspective', 'raw')
729
+ const r = await request(url, {headers: {authorization: `Bearer ${token}`}})
730
+ if (!r.ok) return null
731
+ const docs = r.body.result ?? []
732
+ const todo = docs.map((doc) => ({doc, missing: missingTypes(doc)})).filter((x) => x.missing.length)
733
+ return {api, dataset, token, docs: docs.length, todo, count: todo.reduce((n, x) => n + x.missing.length, 0)}
734
+ }
735
+
736
+ async function itemTypes() {
737
+ const dir = resolve(flag('dir') ?? process.cwd())
738
+ if (!existsSync(join(dir, 'package.json'))) fail(`Pas de package.json dans ${dir} : lance la commande depuis le dossier du studio, ou passe --dir.`)
739
+ if (!sanityToken()) fail('Aucun jeton Sanity : lance `npx sanity login`, ou exporte SANITY_AUTH_TOKEN.')
740
+ const scan = await scanItemTypes(dir)
741
+ if (!scan) fail('Contrôle impossible : SANITY_STUDIO_PROJECT_ID absent, `sanity schema extract` en échec, ou lecture Sanity refusée.')
742
+ if (!scan.count) {
743
+ console.log(`✓ Éléments de liste : tous ont leur _type (${scan.docs} documents).`)
744
+ return
745
+ }
746
+ for (const {doc, missing} of scan.todo) {
747
+ console.log(`${doc._id} (${doc._type}) : ${missing.length} élément(s) sans _type`)
748
+ for (const m of missing) console.log(` ${m.path} -> ${m.expected ?? '? (plusieurs types possibles)'}`)
749
+ }
750
+ if (!has('apply')) {
751
+ console.error(`\n✖ ${scan.count} élément(s) de liste sans _type dans ${scan.todo.length} document(s).`)
752
+ console.error(' Correction : npx ncf-kit item-types --apply (patch ciblé), puis corriger le script qui les a écrits.')
753
+ process.exit(1)
754
+ }
755
+ const {itemTypesPatch} = await import('./item-types.mjs')
756
+ const {randomBytes} = await import('node:crypto')
757
+ const mutations = scan.todo.map(({doc, missing}) => itemTypesPatch(doc, missing, () => randomBytes(6).toString('hex'))).filter(Boolean)
758
+ const headers = {authorization: `Bearer ${scan.token}`, 'content-type': 'application/json'}
759
+ const r = await request(`${scan.api}/mutate/${scan.dataset}`, {method: 'POST', headers, body: JSON.stringify({mutations})})
760
+ if (!r.ok) fail(`Écriture Sanity refusée (${r.status}) : ${JSON.stringify(r.body).slice(0, 300)}`)
761
+ const manual = scan.todo.flatMap(({doc, missing}) => missing.filter((m) => !m.expected).map((m) => `${doc._id} ${m.path}`))
762
+ console.log(`\n✓ ${scan.count - manual.length} _type ajouté(s) par patch ciblé.`)
763
+ if (manual.length) {
764
+ console.error(`✖ Plusieurs types possibles, à corriger dans le Studio :\n ${manual.join('\n ')}`)
765
+ process.exit(1)
766
+ }
767
+ }
768
+
674
769
  async function translations() {
675
770
  const sub = args[1] && !args[1].startsWith('--') ? args[1] : 'export'
676
771
  const dir = resolve(flag('dir') ?? process.cwd())
@@ -935,6 +1030,8 @@ if (command === 'setup') {
935
1030
  .catch((error) => fail(error?.message ?? String(error)))
936
1031
  } else if (command === 'translate-json') {
937
1032
  translateJson().catch((error) => fail(error?.message ?? String(error)))
1033
+ } else if (command === 'item-types') {
1034
+ itemTypes().catch((error) => fail(error?.message ?? String(error)))
938
1035
  } else if (command === 'translations') {
939
1036
  translations().catch((error) => fail(error?.message ?? String(error)))
940
1037
  } else if (command === 'check-environments') {
package/dist/index.d.ts CHANGED
@@ -1427,7 +1427,7 @@ export declare function ActorName(props: {
1427
1427
  * quelle version. Recopiée de `package.json` par `npm version` (scripts/sync-version.mjs) ; un test
1428
1428
  * le vérifie.
1429
1429
  */
1430
- export declare const KIT_VERSION = "2.54.0";
1430
+ export declare const KIT_VERSION = "2.58.0";
1431
1431
  /**
1432
1432
  * Données de la page proposées comme colonnes.
1433
1433
  *
@@ -1901,9 +1901,29 @@ export declare function humanizeBlockName(type: string, namespace: string): stri
1901
1901
  * ```ts
1902
1902
  * S.listItem().title('Articles').child(ncfCollectionTable(S, ncfOptions, 'article'))
1903
1903
  * ```
1904
+ *
1905
+ * `filter`/`params` posent la table au **niveau feuille** (une langue, une
1906
+ * catégorie…) sans mélanger le reste ; `newTemplate` garde la création
1907
+ * pré-taguée de ce niveau ; `id` sert quand un même type a plusieurs tables
1908
+ * (ex. une par langue), pour des identifiants de structure uniques.
1909
+ *
1910
+ * ```ts
1911
+ * S.documentList() // ancien niveau feuille…
1912
+ * ncfCollectionTable(S, ncfOptions, 'newsArticle', {
1913
+ * id: `ncf-col-newsArticle-${lang}`,
1914
+ * title: `News (${lang})`,
1915
+ * filter: 'language == $lang',
1916
+ * params: {lang},
1917
+ * newTemplate: `newsArticle-${lang}`,
1918
+ * })
1919
+ * ```
1904
1920
  */
1905
1921
  export declare function ncfCollectionTable(S: StructureBuilder, options: NcfKitConfig, type: string, opts?: {
1906
1922
  title?: string;
1923
+ id?: string;
1924
+ filter?: string;
1925
+ params?: Record<string, unknown>;
1926
+ newTemplate?: string;
1907
1927
  }): import("sanity/structure").ComponentBuilder;
1908
1928
  /**
1909
1929
  * Entrées « collection » pour la structure du Studio, une par type découvert,
@@ -1917,8 +1937,16 @@ export declare function ncfCollectionTable(S: StructureBuilder, options: NcfKitC
1917
1937
  export declare function ncfCollections(S: StructureBuilder, context: StructureResolverContext, options: NcfKitConfig): ListItemBuilder[];
1918
1938
  interface CollectionTableProps {
1919
1939
  type: string;
1940
+ /** Prédicat GROQ supplémentaire (ex. `language == $lang`) — niveau feuille. */
1941
+ filter?: string;
1942
+ /** Valeurs des paramètres du `filter` (ex. `{lang: 'fr'}`). */
1943
+ params?: Record<string, unknown>;
1944
+ /** Template de création à appliquer au « + » (ex. `article-fr`) : garde la
1945
+ * création pré-taguée (langue, catégorie…) du niveau feuille. Sans lui, le
1946
+ * « + » crée un document nu du type. */
1947
+ newTemplate?: string;
1920
1948
  }
1921
- export declare function CollectionTable({ type }: CollectionTableProps): import("react").JSX.Element;
1949
+ export declare function CollectionTable({ type, filter, params, newTemplate }: CollectionTableProps): import("react").JSX.Element;
1922
1950
  /**
1923
1951
  * Colonnes de la vue table d'une collection.
1924
1952
  *
@@ -1985,12 +2013,22 @@ interface CollectionState {
1985
2013
  error: Error | null;
1986
2014
  refresh: () => void;
1987
2015
  }
2016
+ interface UseCollectionOptions {
2017
+ /** Prédicat GROQ supplémentaire (ex. `language == $lang`) — niveau feuille. */
2018
+ filter?: string;
2019
+ /** Valeurs des paramètres du `filter` (ex. `{lang: 'fr'}`). */
2020
+ params?: Record<string, unknown>;
2021
+ }
1988
2022
  /**
1989
2023
  * Données d'une collection pour la vue table : colonnes tirées du schéma,
1990
2024
  * lignes en direct. Seules les colonnes visibles sont projetées (comme
1991
2025
  * `usePages`), pour ne pas tirer tout le schéma sur chaque document.
2026
+ *
2027
+ * `filter`/`params` restreignent la table au niveau feuille (une langue, une
2028
+ * catégorie…). `useQueryData` stabilise lui-même les paramètres, donc l'objet
2029
+ * peut être reconstruit à chaque rendu sans relancer la requête en boucle.
1992
2030
  */
1993
- export declare function useCollection(type: string, visibleKeys: readonly string[]): CollectionState;
2031
+ export declare function useCollection(type: string, visibleKeys: readonly string[], options?: UseCollectionOptions): CollectionState;
1994
2032
  /**
1995
2033
  * Découverte des types « collection » à montrer en table. Pur : prend la liste
1996
2034
  * des types du schéma (nom + nature JSON) et rend les types de documents
@@ -2025,11 +2063,17 @@ export declare function discoverCollectionTypes(types: readonly SchemaTypeInfo[]
2025
2063
  *
2026
2064
  * Le type passe en paramètre (`$type`), jamais interpolé dans la requête.
2027
2065
  *
2066
+ * `filter` est un prédicat GROQ supplémentaire écrit par l'intégrateur (dans le
2067
+ * résolveur de structure), par exemple `language == $lang` : il restreint la
2068
+ * table au niveau feuille (une langue, une catégorie, une page…). Il est
2069
+ * parenthésé puis combiné en `&&`, et ses valeurs passent par `params`, jamais
2070
+ * interpolées. Même niveau de confiance que `S.documentList().filter(...)`.
2071
+ *
2028
2072
  * On ne filtre pas les brouillons : le client (perspective `raw`) renvoie
2029
2073
  * `drafts.x` ET `x`, que `buildCollectionRows` fusionne par id de base — sans
2030
2074
  * quoi un item jamais publié n'apparaîtrait pas.
2031
2075
  */
2032
- export declare function buildCollectionQuery(columns: readonly CollectionColumn[]): string;
2076
+ export declare function buildCollectionQuery(columns: readonly CollectionColumn[], filter?: string): string;
2033
2077
  type SortDirection$1 = 'asc' | 'desc';
2034
2078
  interface CollectionSort {
2035
2079
  /** Clé de colonne, ou `null` pour l'ordre d'arrivée. */