@nocode-factory/sanity-kit 2.0.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.
- package/bin/ncf-kit.mjs +201 -0
- package/dist/index.d.ts +1643 -0
- package/dist/index.js +6632 -0
- package/dist/index.js.map +1 -0
- package/dist/web-server.d.ts +46 -0
- package/dist/web-server.js +51 -0
- package/dist/web-server.js.map +1 -0
- package/dist/web.d.ts +27 -0
- package/dist/web.js +117 -0
- package/dist/web.js.map +1 -0
- package/package.json +90 -0
- package/scripts/use-client.mjs +20 -0
- package/src/config/defaults.ts +74 -0
- package/src/config/resolve.ts +153 -0
- package/src/config/types.ts +290 -0
- package/src/config/validate.ts +193 -0
- package/src/context/BoardLayoutContext.tsx +24 -0
- package/src/context/KitContext.tsx +30 -0
- package/src/context/PreviewTargetContext.tsx +27 -0
- package/src/hooks/useAnnotations.ts +60 -0
- package/src/hooks/useBoardLayout.ts +398 -0
- package/src/hooks/useColumnOptions.ts +47 -0
- package/src/hooks/useDocumentColumns.ts +61 -0
- package/src/hooks/useHistory.ts +89 -0
- package/src/hooks/useInternalColumns.ts +19 -0
- package/src/hooks/useKitClient.ts +15 -0
- package/src/hooks/useOccurrences.ts +62 -0
- package/src/hooks/usePageContents.ts +65 -0
- package/src/hooks/usePages.ts +41 -0
- package/src/hooks/usePreviewTarget.ts +162 -0
- package/src/hooks/useQueryData.ts +103 -0
- package/src/hooks/useRegistration.ts +50 -0
- package/src/index.ts +280 -0
- package/src/lib/blocks.ts +38 -0
- package/src/lib/colors.ts +103 -0
- package/src/lib/columns.ts +137 -0
- package/src/lib/diff.ts +200 -0
- package/src/lib/elkLayout.ts +124 -0
- package/src/lib/graph.ts +238 -0
- package/src/lib/grouping.ts +116 -0
- package/src/lib/links.ts +70 -0
- package/src/lib/occurrences.ts +93 -0
- package/src/lib/pageThumbnail.ts +43 -0
- package/src/lib/pages.ts +199 -0
- package/src/lib/paths.ts +68 -0
- package/src/lib/query.ts +113 -0
- package/src/lib/schemaColumns.ts +162 -0
- package/src/lib/schemaTypes.ts +75 -0
- package/src/lib/sectionsMap.ts +83 -0
- package/src/lib/service.ts +88 -0
- package/src/lib/siteRoutes.ts +43 -0
- package/src/lib/status.ts +122 -0
- package/src/lib/studioLinks.ts +137 -0
- package/src/schema/boardLayout.ts +190 -0
- package/src/tools/components/BlockCard.tsx +79 -0
- package/src/tools/components/ComponentsTool.tsx +171 -0
- package/src/tools/components/map/SectionNode.tsx +109 -0
- package/src/tools/components/map/SectionsMap.tsx +339 -0
- package/src/tools/createToolComponent.tsx +67 -0
- package/src/tools/history/ChangeRow.tsx +87 -0
- package/src/tools/history/DiffPanel.tsx +227 -0
- package/src/tools/history/HistoryTool.tsx +230 -0
- package/src/tools/more/MoreTool.tsx +82 -0
- package/src/tools/pages/ColumnHeader.tsx +216 -0
- package/src/tools/pages/ColumnVisibility.tsx +173 -0
- package/src/tools/pages/FieldValue.tsx +327 -0
- package/src/tools/pages/PagesTable.tsx +394 -0
- package/src/tools/pages/PagesTool.tsx +333 -0
- package/src/tools/pages/PagesToolbar.tsx +53 -0
- package/src/tools/pages/PathCell.tsx +71 -0
- package/src/tools/pages/PreviewTarget.tsx +226 -0
- package/src/tools/pages/TagCell.tsx +124 -0
- package/src/tools/pages/ViewTabs.tsx +57 -0
- package/src/tools/pages/board/BoardView.tsx +661 -0
- package/src/tools/pages/board/PageNode.tsx +306 -0
- package/src/tools/pages/board/PagePanel.tsx +228 -0
- package/src/tools/presentation/PreviewHeader.tsx +75 -0
- package/src/tools/shared/AnnotationNode.tsx +126 -0
- package/src/ui/ActorName.tsx +20 -0
- package/src/ui/ConfigIssues.tsx +41 -0
- package/src/ui/InlineCode.tsx +22 -0
- package/src/ui/Popover.tsx +85 -0
- package/src/ui/ProjectStatusNotice.tsx +58 -0
- package/src/ui/QueryError.tsx +16 -0
- package/src/ui/QuietInput.tsx +64 -0
- package/src/ui/StatusBadge.tsx +11 -0
- package/src/ui/ToolPlaceholder.tsx +23 -0
- package/src/ui/formatDate.ts +14 -0
- package/src/ui/tokens.ts +54 -0
- package/src/version.ts +5 -0
- package/src/web/PreviewBanner.tsx +115 -0
- package/src/web/draftModeToggle.ts +56 -0
- package/src/web/environment.ts +21 -0
- package/src/web/index.ts +15 -0
- package/src/web/server.ts +11 -0
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,1643 @@
|
|
|
1
|
+
import { SanityClient, Schema, Tool } from "sanity";
|
|
2
|
+
import { ReactNode } from "react";
|
|
3
|
+
import { PreviewHeaderProps } from "sanity/presentation";
|
|
4
|
+
/**
|
|
5
|
+
* Configuration publique du plugin. Tout est optionnel sauf `pageTypes` :
|
|
6
|
+
* le kit ne doit rien savoir du contenu d'un projet client.
|
|
7
|
+
*/
|
|
8
|
+
/** Un type de document considéré comme une page du site. */
|
|
9
|
+
interface NcfPageTypeInput {
|
|
10
|
+
/** Nom du type de document Sanity (ex. 'page'). */
|
|
11
|
+
type: string;
|
|
12
|
+
/**
|
|
13
|
+
* Champ de type `slug` portant l'URL. Hérite de `slugField` global.
|
|
14
|
+
* Mettre à `null` pour un type sans slug : `path` devient obligatoire.
|
|
15
|
+
*/
|
|
16
|
+
slugField?: string | null;
|
|
17
|
+
/**
|
|
18
|
+
* Chemin fixe, pour les pages sans slug (ex. l'accueil : '/').
|
|
19
|
+
* Prioritaire sur `slugField` quand les deux sont renseignés.
|
|
20
|
+
*/
|
|
21
|
+
path?: string;
|
|
22
|
+
/**
|
|
23
|
+
* Préfixe d'URL placé devant le slug, pour les collections servies sous un
|
|
24
|
+
* répertoire : `pathPrefix: '/blog'` donne `/blog/<slug>`. Sans effet avec
|
|
25
|
+
* `path`. C'est la clé `pathPrefix` du registre `site-routes.json` du starter.
|
|
26
|
+
*/
|
|
27
|
+
pathPrefix?: string;
|
|
28
|
+
/** Champ portant le titre affiché. Hérite de `titleField` global. */
|
|
29
|
+
titleField?: string;
|
|
30
|
+
}
|
|
31
|
+
type NcfPageTypeConfig = string | NcfPageTypeInput;
|
|
32
|
+
/** Sites multilingues (ex. @sanity/document-internationalization). */
|
|
33
|
+
interface NcfI18nConfig {
|
|
34
|
+
/** Champ portant le code de langue sur le document. */
|
|
35
|
+
field?: string;
|
|
36
|
+
/** Langue servie à la racine, sans préfixe d'URL. */
|
|
37
|
+
defaultLocale?: string;
|
|
38
|
+
/** Langues attendues. Vide = déduites des documents rencontrés. */
|
|
39
|
+
locales?: string[];
|
|
40
|
+
}
|
|
41
|
+
/**
|
|
42
|
+
* Aperçu visuel des blocs du page builder. Aujourd'hui un seul fournisseur :
|
|
43
|
+
* la page « design system » du front, avec les captures générées par la CI.
|
|
44
|
+
* Storybook viendra s'ajouter ici le jour où un projet en aura un.
|
|
45
|
+
*/
|
|
46
|
+
interface NcfComponentPreviewConfig {
|
|
47
|
+
provider?: 'designSystemPage' | 'none';
|
|
48
|
+
/** Chemin de la page de démonstration, relatif à `previewUrl`. */
|
|
49
|
+
path?: string;
|
|
50
|
+
/** Ancre vers le bloc sur cette page. Gabarit : {name} / {kebab}. */
|
|
51
|
+
anchor?: string;
|
|
52
|
+
/** Chemin de la capture, relatif à `previewUrl`. Gabarit : {name} / {kebab}. */
|
|
53
|
+
thumbnail?: string;
|
|
54
|
+
}
|
|
55
|
+
/** Journal des modifications (phase 2). */
|
|
56
|
+
interface NcfHistoryConfig {
|
|
57
|
+
/**
|
|
58
|
+
* Clé de lecture du projet, écrite dans `studio/.env` par `npx ncf-kit setup`
|
|
59
|
+
* (variable `SANITY_STUDIO_NCF_PROJECT_KEY`). Elle voyage dans le bundle du
|
|
60
|
+
* Studio : imprévisible, pas confidentielle. Jamais une clé d'écriture.
|
|
61
|
+
* Vide ou absente : l'onglet Historique explique comment l'obtenir.
|
|
62
|
+
*/
|
|
63
|
+
projectKey?: string;
|
|
64
|
+
/** Base des Edge Functions. Par défaut, le service du kit. */
|
|
65
|
+
endpoint?: string;
|
|
66
|
+
}
|
|
67
|
+
/** Étiquette de suivi posable sur une page dans le board. */
|
|
68
|
+
interface NcfBoardTag {
|
|
69
|
+
/** Identifiant stable, enregistré dans le document de disposition. */
|
|
70
|
+
id: string;
|
|
71
|
+
label: string;
|
|
72
|
+
/** Couleur CSS de la pastille et de la bordure du nœud. */
|
|
73
|
+
color: string;
|
|
74
|
+
}
|
|
75
|
+
/** Choix possible d'un champ de gestion interne de type « select ». */
|
|
76
|
+
interface NcfInternalFieldOption {
|
|
77
|
+
id: string;
|
|
78
|
+
label: string;
|
|
79
|
+
/** Couleur de la pastille. Sans elle, le choix s'affiche en texte. */
|
|
80
|
+
color?: string;
|
|
81
|
+
}
|
|
82
|
+
/**
|
|
83
|
+
* Champ de suivi éditorial, libre. Autant qu'on veut : responsable, cible,
|
|
84
|
+
* rôle de la page… Ces valeurs vivent dans le document du kit, jamais dans le
|
|
85
|
+
* schéma du client.
|
|
86
|
+
*/
|
|
87
|
+
interface NcfInternalField {
|
|
88
|
+
/** Identifiant stable, enregistré avec la valeur. */
|
|
89
|
+
id: string;
|
|
90
|
+
label: string;
|
|
91
|
+
/** `text` par défaut. `select` exige `options`. */
|
|
92
|
+
type?: 'text' | 'select';
|
|
93
|
+
options?: NcfInternalFieldOption[];
|
|
94
|
+
}
|
|
95
|
+
/**
|
|
96
|
+
* Donnée du document de la page, affichable telle quelle dans une colonne.
|
|
97
|
+
*
|
|
98
|
+
* Réservé aux valeurs qui tiennent sur une ligne : une meta description, un
|
|
99
|
+
* booléen d'indexabilité, une date. Surtout pas un tableau de sections, qu'on
|
|
100
|
+
* ne saurait pas rendre dans une cellule.
|
|
101
|
+
*/
|
|
102
|
+
interface NcfDocumentColumn {
|
|
103
|
+
/** Identifiant stable. Lettres, chiffres et tirets. */
|
|
104
|
+
key: string;
|
|
105
|
+
label: string;
|
|
106
|
+
/** Chemins essayés dans l'ordre, le premier renseigné gagne. */
|
|
107
|
+
path: string | string[];
|
|
108
|
+
/** `text` par défaut. `boolean` affiche Oui/Non. */
|
|
109
|
+
type?: 'text' | 'boolean' | 'number';
|
|
110
|
+
}
|
|
111
|
+
/**
|
|
112
|
+
* Une version du front déployée quelque part : production, préproduction,
|
|
113
|
+
* branche de recette.
|
|
114
|
+
*
|
|
115
|
+
* Le code change d'un environnement à l'autre, **pas les données** : c'est
|
|
116
|
+
* toujours le même dataset qu'on regarde. Voir le contenu de production dans
|
|
117
|
+
* le front d'une branche est justement l'intérêt.
|
|
118
|
+
*/
|
|
119
|
+
interface NcfEnvironment {
|
|
120
|
+
/** Identifiant stable, retenu d'une session à l'autre. */
|
|
121
|
+
id: string;
|
|
122
|
+
label: string;
|
|
123
|
+
/** Base URL du front, sans slash final. */
|
|
124
|
+
url: string;
|
|
125
|
+
}
|
|
126
|
+
interface NcfToolsConfig {
|
|
127
|
+
pages?: boolean;
|
|
128
|
+
components?: boolean;
|
|
129
|
+
history?: boolean;
|
|
130
|
+
}
|
|
131
|
+
interface NcfKitConfig {
|
|
132
|
+
/** Types de documents traités comme des pages. Au moins un. */
|
|
133
|
+
pageTypes: NcfPageTypeConfig[];
|
|
134
|
+
/** Champ tableau du page builder. */
|
|
135
|
+
pageBuilderField?: string;
|
|
136
|
+
/**
|
|
137
|
+
* Préfixe commun aux types de blocs, retiré pour l'affichage et les gabarits
|
|
138
|
+
* d'URL. Ex. 'section.' pour des blocs nommés `section.hero`.
|
|
139
|
+
*/
|
|
140
|
+
blockNamespace?: string;
|
|
141
|
+
/** Champ slug par défaut des `pageTypes`. */
|
|
142
|
+
slugField?: string;
|
|
143
|
+
/** Champ titre par défaut des `pageTypes`. */
|
|
144
|
+
titleField?: string;
|
|
145
|
+
/**
|
|
146
|
+
* Champ booléen marquant une page comme non indexable. Plusieurs chemins
|
|
147
|
+
* sont essayés dans l'ordre, le premier renseigné gagne.
|
|
148
|
+
* Défaut : `['seo.noindex', 'noindex']`.
|
|
149
|
+
*/
|
|
150
|
+
noindexField?: string | string[];
|
|
151
|
+
/** Base URL du front, sans slash final. */
|
|
152
|
+
previewUrl?: string;
|
|
153
|
+
/**
|
|
154
|
+
* Fronts déployés entre lesquels basculer dans l'aperçu. Sans eux, le seul
|
|
155
|
+
* environnement proposé est `previewUrl`.
|
|
156
|
+
*
|
|
157
|
+
* Leurs origines doivent figurer dans `allowOrigins` de `presentationTool` :
|
|
158
|
+
* `ncfAllowedOrigins(config)` les produit.
|
|
159
|
+
*/
|
|
160
|
+
environments?: NcfEnvironment[];
|
|
161
|
+
/**
|
|
162
|
+
* Gabarit d'URL de la capture d'une page, pour afficher la page entière dans
|
|
163
|
+
* le board plutôt qu'une iframe tronquée. Variables : {slug} (chemin sans
|
|
164
|
+
* slash de tête, avec des tirets), {locale}, {id}.
|
|
165
|
+
*
|
|
166
|
+
* Chemin relatif à `previewUrl` (« /pages/{slug}.png ») ou URL absolue.
|
|
167
|
+
* Vide : le board retombe sur l'aperçu iframe en direct.
|
|
168
|
+
*/
|
|
169
|
+
pageThumbnail?: string;
|
|
170
|
+
/** `false` (défaut) pour un site monolingue. */
|
|
171
|
+
i18n?: NcfI18nConfig | false;
|
|
172
|
+
componentPreview?: NcfComponentPreviewConfig;
|
|
173
|
+
history?: NcfHistoryConfig;
|
|
174
|
+
/**
|
|
175
|
+
* Base des Edge Functions du kit, pour l'enregistrement et l'historique.
|
|
176
|
+
* `false` coupe tout appel sortant, y compris le signalement de présence.
|
|
177
|
+
*/
|
|
178
|
+
serviceEndpoint?: string | false;
|
|
179
|
+
/** Permet de n'activer qu'une partie des outils. */
|
|
180
|
+
tools?: NcfToolsConfig;
|
|
181
|
+
/**
|
|
182
|
+
* Étiquettes de suivi du board. Remplacent entièrement les valeurs par
|
|
183
|
+
* défaut quand elles sont fournies.
|
|
184
|
+
*/
|
|
185
|
+
boardTags?: NcfBoardTag[];
|
|
186
|
+
/**
|
|
187
|
+
* Colonnes de l'onglet « Gestion interne » de la liste des pages.
|
|
188
|
+
* Remplacent entièrement les valeurs par défaut quand elles sont fournies.
|
|
189
|
+
*/
|
|
190
|
+
internalFields?: NcfInternalField[];
|
|
191
|
+
/**
|
|
192
|
+
* Données du document affichables en colonne, proposées dans le sélecteur de
|
|
193
|
+
* colonnes. Masquées tant que personne ne les coche.
|
|
194
|
+
* Défaut : meta description, titre SEO, indexabilité.
|
|
195
|
+
*/
|
|
196
|
+
documentColumns?: NcfDocumentColumn[];
|
|
197
|
+
}
|
|
198
|
+
interface ResolvedPageType {
|
|
199
|
+
type: string;
|
|
200
|
+
slugField: string | null;
|
|
201
|
+
path: string | null;
|
|
202
|
+
/** Préfixe normalisé ('/blog'), `null` pour une collection à la racine. */
|
|
203
|
+
pathPrefix: string | null;
|
|
204
|
+
titleField: string;
|
|
205
|
+
}
|
|
206
|
+
interface ResolvedI18n {
|
|
207
|
+
field: string;
|
|
208
|
+
defaultLocale: string;
|
|
209
|
+
locales: string[];
|
|
210
|
+
}
|
|
211
|
+
interface ResolvedComponentPreview {
|
|
212
|
+
provider: 'designSystemPage' | 'none';
|
|
213
|
+
path: string;
|
|
214
|
+
anchor: string;
|
|
215
|
+
thumbnail: string;
|
|
216
|
+
}
|
|
217
|
+
interface ResolvedKitConfig {
|
|
218
|
+
pageTypes: ResolvedPageType[];
|
|
219
|
+
pageTypeNames: string[];
|
|
220
|
+
pageBuilderField: string;
|
|
221
|
+
blockNamespace: string;
|
|
222
|
+
noindexFields: string[];
|
|
223
|
+
previewUrl: string | null;
|
|
224
|
+
environments: NcfEnvironment[];
|
|
225
|
+
pageThumbnail: string | null;
|
|
226
|
+
i18n: ResolvedI18n | null;
|
|
227
|
+
componentPreview: ResolvedComponentPreview;
|
|
228
|
+
history: ResolvedHistory | null;
|
|
229
|
+
/** `null` quand on a explicitement coupé les appels sortants. */
|
|
230
|
+
serviceEndpoint: string | null;
|
|
231
|
+
tools: Required<NcfToolsConfig>;
|
|
232
|
+
boardTags: NcfBoardTag[];
|
|
233
|
+
internalFields: NcfInternalField[];
|
|
234
|
+
documentColumns: ResolvedDocumentColumn[];
|
|
235
|
+
}
|
|
236
|
+
interface ResolvedHistory {
|
|
237
|
+
projectKey: string;
|
|
238
|
+
endpoint: string;
|
|
239
|
+
}
|
|
240
|
+
interface ResolvedDocumentColumn {
|
|
241
|
+
key: string;
|
|
242
|
+
label: string;
|
|
243
|
+
/** Chemins retenus, nettoyés. */
|
|
244
|
+
paths: string[];
|
|
245
|
+
type: 'text' | 'boolean' | 'number';
|
|
246
|
+
/**
|
|
247
|
+
* Inverse un booléen à l'affichage. Sert à `noindex`, qu'on veut lire
|
|
248
|
+
* « Indexable : oui » plutôt que « Noindex : non ».
|
|
249
|
+
*/
|
|
250
|
+
invert?: boolean;
|
|
251
|
+
}
|
|
252
|
+
type IssueLevel = 'error' | 'warning';
|
|
253
|
+
/**
|
|
254
|
+
* Un problème de configuration. `error` neutralise l'outil concerné (mais pas
|
|
255
|
+
* le Studio) ; `warning` laisse l'outil fonctionner en mode dégradé.
|
|
256
|
+
*/
|
|
257
|
+
interface ConfigIssue {
|
|
258
|
+
level: IssueLevel;
|
|
259
|
+
/** Chemin de l'option fautive, ex. 'pageTypes[1].slugField'. */
|
|
260
|
+
path: string;
|
|
261
|
+
message: string;
|
|
262
|
+
/** Quels outils sont concernés. Vide = tous. */
|
|
263
|
+
tools?: NcfToolName[];
|
|
264
|
+
}
|
|
265
|
+
type NcfToolName = 'pages' | 'components' | 'history';
|
|
266
|
+
interface KitContextValue {
|
|
267
|
+
config: ResolvedKitConfig;
|
|
268
|
+
issues: ConfigIssue[];
|
|
269
|
+
}
|
|
270
|
+
/** Garantit un chemin absolu ('accueil' -> '/accueil', '' -> '/'). */
|
|
271
|
+
export declare const normalizePath: (path: string) => string;
|
|
272
|
+
/** Applique les valeurs par défaut. Ne valide rien : voir `validateConfig`. */
|
|
273
|
+
export declare function resolveConfig(input: NcfKitConfig): ResolvedKitConfig;
|
|
274
|
+
/**
|
|
275
|
+
* Contrôle la configuration résolue. Ne lève jamais : les problèmes sont
|
|
276
|
+
* rendus dans l'onglet concerné, pour qu'une faute de frappe dans
|
|
277
|
+
* sanity.config.ts ne rende pas le Studio entier inutilisable.
|
|
278
|
+
*/
|
|
279
|
+
export declare function validateConfig(config: ResolvedKitConfig): ConfigIssue[];
|
|
280
|
+
/** Problèmes bloquant un outil donné. */
|
|
281
|
+
export declare function issuesForTool(issues: ConfigIssue[], tool: NcfToolName): ConfigIssue[];
|
|
282
|
+
export declare function hasBlockingIssue(issues: ConfigIssue[], tool: NcfToolName): boolean;
|
|
283
|
+
export declare const DEFAULT_PAGE_BUILDER_FIELD = "sections";
|
|
284
|
+
export declare const DEFAULT_SLUG_FIELD = "slug";
|
|
285
|
+
export declare const DEFAULT_TITLE_FIELD = "title";
|
|
286
|
+
export declare const DEFAULT_I18N: Required<NcfI18nConfig>;
|
|
287
|
+
/**
|
|
288
|
+
* Convention NoCode Factory : page `/design-system` dans le front, captures
|
|
289
|
+
* dans `/sections/<nom>.png` générées au push par GitHub Actions.
|
|
290
|
+
*/
|
|
291
|
+
export declare const DEFAULT_COMPONENT_PREVIEW: Required<NcfComponentPreviewConfig>;
|
|
292
|
+
/**
|
|
293
|
+
* Étiquettes de suivi par défaut : l'avancement d'une refonte, pas un statut
|
|
294
|
+
* de publication. Elles vivent dans le document de disposition du kit, donc
|
|
295
|
+
* aucun schéma client n'est modifié.
|
|
296
|
+
*/
|
|
297
|
+
export declare const DEFAULT_BOARD_TAGS: NcfBoardTag[];
|
|
298
|
+
/**
|
|
299
|
+
* Colonnes de gestion interne par défaut. Volontairement peu nombreuses : ce
|
|
300
|
+
* sont celles qu'on redemande sur tous les projets. `internalFields` les
|
|
301
|
+
* remplace entièrement.
|
|
302
|
+
*/
|
|
303
|
+
export declare const DEFAULT_INTERNAL_FIELDS: NcfInternalField[];
|
|
304
|
+
/** Type et identifiant du singleton portant la disposition du board. */
|
|
305
|
+
export declare const BOARD_LAYOUT_TYPE = "ncfBoardLayout";
|
|
306
|
+
export declare const BOARD_LAYOUT_ID = "ncfBoardLayout";
|
|
307
|
+
export declare const SECTION_NODE_TYPE = "ncfSectionNode";
|
|
308
|
+
export declare const NODE_FIELD_TYPE = "ncfNodeField";
|
|
309
|
+
export declare const COLUMN_TYPE = "ncfColumn";
|
|
310
|
+
export declare const ANNOTATION_TYPE = "ncfAnnotation";
|
|
311
|
+
/** Types déclarés par le kit : à masquer de la structure du Studio hôte. */
|
|
312
|
+
export declare const NCF_HIDDEN_TYPES: readonly ["ncfBoardLayout"];
|
|
313
|
+
export declare const kitSchemaTypes: ({
|
|
314
|
+
name: "ncfBoardLayout";
|
|
315
|
+
title: string;
|
|
316
|
+
type: "document";
|
|
317
|
+
fields: ({
|
|
318
|
+
name: "nodes";
|
|
319
|
+
title: string;
|
|
320
|
+
type: "array";
|
|
321
|
+
of: {
|
|
322
|
+
type: string;
|
|
323
|
+
}[];
|
|
324
|
+
} | {
|
|
325
|
+
name: "annotations";
|
|
326
|
+
title: string;
|
|
327
|
+
type: "array";
|
|
328
|
+
of: {
|
|
329
|
+
type: string;
|
|
330
|
+
}[];
|
|
331
|
+
} | {
|
|
332
|
+
name: "columns";
|
|
333
|
+
title: string;
|
|
334
|
+
type: "array";
|
|
335
|
+
of: {
|
|
336
|
+
type: string;
|
|
337
|
+
}[];
|
|
338
|
+
} | {
|
|
339
|
+
name: "columnsSet";
|
|
340
|
+
title: string;
|
|
341
|
+
type: "boolean";
|
|
342
|
+
} | {
|
|
343
|
+
name: "sections";
|
|
344
|
+
title: string;
|
|
345
|
+
type: "array";
|
|
346
|
+
of: {
|
|
347
|
+
type: string;
|
|
348
|
+
}[];
|
|
349
|
+
} | {
|
|
350
|
+
name: "updatedBy";
|
|
351
|
+
title: string;
|
|
352
|
+
type: "string";
|
|
353
|
+
readOnly: true;
|
|
354
|
+
})[];
|
|
355
|
+
preview: {
|
|
356
|
+
prepare: () => {
|
|
357
|
+
title: string;
|
|
358
|
+
};
|
|
359
|
+
};
|
|
360
|
+
} | {
|
|
361
|
+
name: "ncfBoardNode";
|
|
362
|
+
title: string;
|
|
363
|
+
type: "object";
|
|
364
|
+
fields: ({
|
|
365
|
+
name: "documentId";
|
|
366
|
+
title: string;
|
|
367
|
+
type: "string";
|
|
368
|
+
} | {
|
|
369
|
+
name: "x";
|
|
370
|
+
title: string;
|
|
371
|
+
type: "number";
|
|
372
|
+
} | {
|
|
373
|
+
name: "y";
|
|
374
|
+
title: string;
|
|
375
|
+
type: "number";
|
|
376
|
+
} | {
|
|
377
|
+
name: "width";
|
|
378
|
+
title: string;
|
|
379
|
+
type: "number";
|
|
380
|
+
} | {
|
|
381
|
+
name: "height";
|
|
382
|
+
title: string;
|
|
383
|
+
type: "number";
|
|
384
|
+
} | {
|
|
385
|
+
name: "tag";
|
|
386
|
+
title: string;
|
|
387
|
+
type: "string";
|
|
388
|
+
} | {
|
|
389
|
+
name: "fields";
|
|
390
|
+
title: string;
|
|
391
|
+
type: "array";
|
|
392
|
+
of: {
|
|
393
|
+
type: string;
|
|
394
|
+
}[];
|
|
395
|
+
})[];
|
|
396
|
+
preview: {
|
|
397
|
+
select: {
|
|
398
|
+
title: string;
|
|
399
|
+
x: string;
|
|
400
|
+
y: string;
|
|
401
|
+
};
|
|
402
|
+
prepare: ({ title, x, y }: Record<"title" | "x" | "y", any>) => {
|
|
403
|
+
title: any;
|
|
404
|
+
subtitle: string;
|
|
405
|
+
};
|
|
406
|
+
};
|
|
407
|
+
} | {
|
|
408
|
+
name: "ncfSectionNode";
|
|
409
|
+
title: string;
|
|
410
|
+
type: "object";
|
|
411
|
+
fields: ({
|
|
412
|
+
name: "blockName";
|
|
413
|
+
title: string;
|
|
414
|
+
type: "string";
|
|
415
|
+
} | {
|
|
416
|
+
name: "x";
|
|
417
|
+
title: string;
|
|
418
|
+
type: "number";
|
|
419
|
+
} | {
|
|
420
|
+
name: "y";
|
|
421
|
+
title: string;
|
|
422
|
+
type: "number";
|
|
423
|
+
})[];
|
|
424
|
+
preview: {
|
|
425
|
+
select: {
|
|
426
|
+
title: string;
|
|
427
|
+
x: string;
|
|
428
|
+
y: string;
|
|
429
|
+
};
|
|
430
|
+
prepare: ({ title, x, y }: Record<"title" | "x" | "y", any>) => {
|
|
431
|
+
title: any;
|
|
432
|
+
subtitle: string;
|
|
433
|
+
};
|
|
434
|
+
};
|
|
435
|
+
} | {
|
|
436
|
+
name: "ncfNodeField";
|
|
437
|
+
title: string;
|
|
438
|
+
type: "object";
|
|
439
|
+
fields: ({
|
|
440
|
+
name: "fieldId";
|
|
441
|
+
title: string;
|
|
442
|
+
type: "string";
|
|
443
|
+
} | {
|
|
444
|
+
name: "value";
|
|
445
|
+
title: string;
|
|
446
|
+
type: "string";
|
|
447
|
+
})[];
|
|
448
|
+
preview: {
|
|
449
|
+
select: {
|
|
450
|
+
title: string;
|
|
451
|
+
subtitle: string;
|
|
452
|
+
};
|
|
453
|
+
};
|
|
454
|
+
} | {
|
|
455
|
+
name: "ncfColumn";
|
|
456
|
+
title: string;
|
|
457
|
+
type: "object";
|
|
458
|
+
fields: ({
|
|
459
|
+
name: "id";
|
|
460
|
+
title: string;
|
|
461
|
+
type: "string";
|
|
462
|
+
} | {
|
|
463
|
+
name: "label";
|
|
464
|
+
title: string;
|
|
465
|
+
type: "string";
|
|
466
|
+
} | {
|
|
467
|
+
name: "type";
|
|
468
|
+
title: string;
|
|
469
|
+
type: "string";
|
|
470
|
+
options: {
|
|
471
|
+
list: {
|
|
472
|
+
title: string;
|
|
473
|
+
value: string;
|
|
474
|
+
}[];
|
|
475
|
+
};
|
|
476
|
+
} | {
|
|
477
|
+
name: "options";
|
|
478
|
+
title: string;
|
|
479
|
+
type: "array";
|
|
480
|
+
of: {
|
|
481
|
+
type: string;
|
|
482
|
+
}[];
|
|
483
|
+
})[];
|
|
484
|
+
preview: {
|
|
485
|
+
select: {
|
|
486
|
+
title: string;
|
|
487
|
+
subtitle: string;
|
|
488
|
+
};
|
|
489
|
+
};
|
|
490
|
+
} | {
|
|
491
|
+
name: "ncfColumnOption";
|
|
492
|
+
title: string;
|
|
493
|
+
type: "object";
|
|
494
|
+
fields: ({
|
|
495
|
+
name: "id";
|
|
496
|
+
title: string;
|
|
497
|
+
type: "string";
|
|
498
|
+
} | {
|
|
499
|
+
name: "label";
|
|
500
|
+
title: string;
|
|
501
|
+
type: "string";
|
|
502
|
+
} | {
|
|
503
|
+
name: "color";
|
|
504
|
+
title: string;
|
|
505
|
+
type: "string";
|
|
506
|
+
})[];
|
|
507
|
+
preview: {
|
|
508
|
+
select: {
|
|
509
|
+
title: string;
|
|
510
|
+
subtitle: string;
|
|
511
|
+
};
|
|
512
|
+
};
|
|
513
|
+
} | {
|
|
514
|
+
name: "ncfAnnotation";
|
|
515
|
+
title: string;
|
|
516
|
+
type: "object";
|
|
517
|
+
fields: ({
|
|
518
|
+
name: "id";
|
|
519
|
+
title: string;
|
|
520
|
+
type: "string";
|
|
521
|
+
} | {
|
|
522
|
+
name: "scope";
|
|
523
|
+
title: string;
|
|
524
|
+
type: "string";
|
|
525
|
+
options: {
|
|
526
|
+
list: {
|
|
527
|
+
title: string;
|
|
528
|
+
value: string;
|
|
529
|
+
}[];
|
|
530
|
+
};
|
|
531
|
+
} | {
|
|
532
|
+
name: "kind";
|
|
533
|
+
title: string;
|
|
534
|
+
type: "string";
|
|
535
|
+
options: {
|
|
536
|
+
list: {
|
|
537
|
+
title: string;
|
|
538
|
+
value: string;
|
|
539
|
+
}[];
|
|
540
|
+
};
|
|
541
|
+
} | {
|
|
542
|
+
name: "x";
|
|
543
|
+
type: "number";
|
|
544
|
+
} | {
|
|
545
|
+
name: "y";
|
|
546
|
+
type: "number";
|
|
547
|
+
} | {
|
|
548
|
+
name: "width";
|
|
549
|
+
type: "number";
|
|
550
|
+
} | {
|
|
551
|
+
name: "height";
|
|
552
|
+
type: "number";
|
|
553
|
+
} | {
|
|
554
|
+
name: "text";
|
|
555
|
+
title: string;
|
|
556
|
+
type: "string";
|
|
557
|
+
} | {
|
|
558
|
+
name: "color";
|
|
559
|
+
title: string;
|
|
560
|
+
type: "string";
|
|
561
|
+
})[];
|
|
562
|
+
preview: {
|
|
563
|
+
select: {
|
|
564
|
+
title: string;
|
|
565
|
+
subtitle: string;
|
|
566
|
+
};
|
|
567
|
+
};
|
|
568
|
+
})[];
|
|
569
|
+
/** Vrai pour les types techniques du kit. */
|
|
570
|
+
export declare const isKitType: (typeName: string) => boolean;
|
|
571
|
+
/**
|
|
572
|
+
* Configuration résolue du kit. Erreur explicite hors contexte : une
|
|
573
|
+
* dépendance oubliée se voit tout de suite au développement.
|
|
574
|
+
*/
|
|
575
|
+
export declare function useKitContext(): KitContextValue;
|
|
576
|
+
export declare const useKitConfig: () => ResolvedKitConfig;
|
|
577
|
+
interface PathInput {
|
|
578
|
+
/** Valeur du champ slug (`slug.current`). Peut contenir des `/`. */
|
|
579
|
+
slug?: string | null;
|
|
580
|
+
/** Chemin fixe du type de page, s'il en a un. */
|
|
581
|
+
path?: string | null;
|
|
582
|
+
/** Préfixe d'URL du type de page ('/blog'), devant le slug. */
|
|
583
|
+
pathPrefix?: string | null;
|
|
584
|
+
/** Langue du document. */
|
|
585
|
+
locale?: string | null;
|
|
586
|
+
}
|
|
587
|
+
/**
|
|
588
|
+
* Chemin d'une page sur le site. Le chemin fixe l'emporte sur le slug, le
|
|
589
|
+
* préfixe du type se place devant le slug ('/blog' + 'mon-article'), et la
|
|
590
|
+
* langue par défaut n'est pas préfixée (convention Next.js du starter).
|
|
591
|
+
*/
|
|
592
|
+
export declare function toPath(input: PathInput, i18n: ResolvedI18n | null): string | null;
|
|
593
|
+
/** URL absolue d'une page, ou `null` si le front n'est pas configuré. */
|
|
594
|
+
export declare function toUrl(previewUrl: string | null, path: string | null): string | null;
|
|
595
|
+
/** Segments d'un chemin : '/services/plomberie' -> ['services', 'plomberie']. */
|
|
596
|
+
export declare function segments(path: string): string[];
|
|
597
|
+
/** Profondeur dans l'arborescence. '/' vaut 0. */
|
|
598
|
+
export declare function depth(path: string): number;
|
|
599
|
+
/**
|
|
600
|
+
* Chemin du parent, ou `null` à la racine. Sert au placement automatique du
|
|
601
|
+
* board : '/services/plomberie' -> '/services'.
|
|
602
|
+
*/
|
|
603
|
+
export declare function parentPath(path: string): string | null;
|
|
604
|
+
/** Le type de page correspondant à un document. */
|
|
605
|
+
export declare function pageTypeFor(type: string, pageTypes: ResolvedPageType[]): ResolvedPageType | undefined;
|
|
606
|
+
/**
|
|
607
|
+
* Registre des pages du starter NoCode Factory (`web/app/lib/site-routes.json`).
|
|
608
|
+
* Seules les clés lues ici sont typées : le fichier en porte d'autres
|
|
609
|
+
* (sections, titres, noindex) qui ne concernent pas le kit.
|
|
610
|
+
*/
|
|
611
|
+
interface SiteRoutesRegistry {
|
|
612
|
+
fixed?: {
|
|
613
|
+
path: string;
|
|
614
|
+
homePage?: boolean;
|
|
615
|
+
system?: boolean;
|
|
616
|
+
notFound?: boolean;
|
|
617
|
+
}[];
|
|
618
|
+
collections?: {
|
|
619
|
+
type: string;
|
|
620
|
+
pathPrefix?: string;
|
|
621
|
+
}[];
|
|
622
|
+
}
|
|
623
|
+
/**
|
|
624
|
+
* `pageTypes` déduits du registre du starter, pour ne pas redire au kit ce que
|
|
625
|
+
* le site sait déjà : l'accueil (chemin fixe `/`) et chaque collection avec
|
|
626
|
+
* son préfixe d'URL (`/blog`, `/produits`, ou la racine).
|
|
627
|
+
*
|
|
628
|
+
* ```ts
|
|
629
|
+
* import routes from '../web/app/lib/site-routes.json'
|
|
630
|
+
* ncfKit({pageTypes: pageTypesFromSiteRoutes(routes)})
|
|
631
|
+
* ```
|
|
632
|
+
*
|
|
633
|
+
* `homePageType` : nom du type de l'accueil dans le schéma (le registre ne le
|
|
634
|
+
* porte pas). Les pages codées du registre (`pageSlug`) ne sont pas des types :
|
|
635
|
+
* elles n'apparaissent pas ici.
|
|
636
|
+
*/
|
|
637
|
+
export declare function pageTypesFromSiteRoutes(routes: SiteRoutesRegistry, options?: {
|
|
638
|
+
homePageType?: string | null;
|
|
639
|
+
}): NcfPageTypeInput[];
|
|
640
|
+
/** Nom de l'onglet « Plus » dans la barre du Studio. */
|
|
641
|
+
export declare const NCF_MORE_TOOL = "ncf-more";
|
|
642
|
+
/** Outils qu'on range par défaut : utiles aux développeurs, pas aux éditeurs. */
|
|
643
|
+
export declare const DEFAULT_MORE_TOOLS: string[];
|
|
644
|
+
/**
|
|
645
|
+
* Range les outils nommés dans un onglet « Plus » en fin de barre.
|
|
646
|
+
*
|
|
647
|
+
* À appeler dans le `tools` du workspace, pas dans un plugin : c'est le seul
|
|
648
|
+
* endroit qui voit tous les outils, ceux des plugins déclarés après le kit et
|
|
649
|
+
* ceux du Studio lui-même (Releases).
|
|
650
|
+
*
|
|
651
|
+
* ```ts
|
|
652
|
+
* tools: (prev) => withMoreTool(prev, ['vision', 'releases'])
|
|
653
|
+
* ```
|
|
654
|
+
*
|
|
655
|
+
* Aucun des outils nommés n'est présent : la barre est rendue telle quelle.
|
|
656
|
+
*/
|
|
657
|
+
export declare function withMoreTool(tools: Tool[], names?: string[]): Tool[];
|
|
658
|
+
/**
|
|
659
|
+
* Fusion des variantes d'un même document (publié / brouillon / version de
|
|
660
|
+
* release) pour en déduire un statut unique affichable.
|
|
661
|
+
*/
|
|
662
|
+
type PageStatus = 'published' | 'draft' | 'modified';
|
|
663
|
+
interface VersionedDoc {
|
|
664
|
+
_id: string;
|
|
665
|
+
_type: string;
|
|
666
|
+
_updatedAt?: string;
|
|
667
|
+
}
|
|
668
|
+
export declare const isDraftId: (id: string) => boolean;
|
|
669
|
+
/** Version issue d'une release de contenu (Sanity v6). */
|
|
670
|
+
export declare const isVersionId: (id: string) => boolean;
|
|
671
|
+
/** Identifiant de la release, pour un id `versions.<release>.<doc>`. */
|
|
672
|
+
export declare function releaseId(id: string): string | null;
|
|
673
|
+
/** Identifiant du document publié, quel que soit l'identifiant reçu. */
|
|
674
|
+
export declare function baseId(id: string): string;
|
|
675
|
+
interface MergedDoc<T extends VersionedDoc> {
|
|
676
|
+
id: string;
|
|
677
|
+
status: PageStatus;
|
|
678
|
+
/** Version de référence pour l'affichage : le brouillon s'il existe. */
|
|
679
|
+
doc: T;
|
|
680
|
+
published?: T;
|
|
681
|
+
draft?: T;
|
|
682
|
+
/** Versions de release, par identifiant de release. */
|
|
683
|
+
versions: Record<string, T>;
|
|
684
|
+
/** Date de la modification la plus récente, toutes variantes confondues. */
|
|
685
|
+
updatedAt?: string;
|
|
686
|
+
}
|
|
687
|
+
/**
|
|
688
|
+
* Regroupe les documents par identifiant de base.
|
|
689
|
+
*
|
|
690
|
+
* - publié seul -> 'published'
|
|
691
|
+
* - brouillon seul -> 'draft' (jamais publié, absent du site)
|
|
692
|
+
* - publié + brouillon -> 'modified' (modifications non publiées)
|
|
693
|
+
*
|
|
694
|
+
* Les versions de release sont conservées mais n'influencent pas le statut :
|
|
695
|
+
* elles ne sont ni en ligne, ni des modifications en attente au sens du Studio.
|
|
696
|
+
*/
|
|
697
|
+
export declare function mergeVersions<T extends VersionedDoc>(docs: readonly T[]): MergedDoc<T>[];
|
|
698
|
+
export declare const STATUS_LABELS: Record<PageStatus, {
|
|
699
|
+
label: string;
|
|
700
|
+
tone: 'positive' | 'caution' | 'default';
|
|
701
|
+
help: string;
|
|
702
|
+
}>;
|
|
703
|
+
/** Document tel que le renvoie `buildPagesQuery`. */
|
|
704
|
+
interface PageDoc extends VersionedDoc {
|
|
705
|
+
ncfTitle?: string | null;
|
|
706
|
+
ncfSlug?: string | null;
|
|
707
|
+
ncfLocale?: string | null;
|
|
708
|
+
ncfBlockCount?: number | null;
|
|
709
|
+
ncfNoindex?: boolean | null;
|
|
710
|
+
/** Projections `ncfData_<clé>` des colonnes de données déclarées. */
|
|
711
|
+
[key: string]: unknown;
|
|
712
|
+
}
|
|
713
|
+
interface PageRow {
|
|
714
|
+
/** Identifiant du document publié (sans préfixe `drafts.`). */
|
|
715
|
+
id: string;
|
|
716
|
+
type: string;
|
|
717
|
+
title: string;
|
|
718
|
+
/** Chemin sur le site, ou `null` si le type n'en permet pas le calcul. */
|
|
719
|
+
path: string | null;
|
|
720
|
+
url: string | null;
|
|
721
|
+
locale: string | null;
|
|
722
|
+
status: PageStatus;
|
|
723
|
+
updatedAt: string | null;
|
|
724
|
+
blockCount: number;
|
|
725
|
+
/** Marquée non indexable dans le CMS. */
|
|
726
|
+
noindex: boolean;
|
|
727
|
+
/** Données du document, déjà mises en forme pour une cellule. */
|
|
728
|
+
data: Record<string, string>;
|
|
729
|
+
}
|
|
730
|
+
/**
|
|
731
|
+
* Met une valeur du document en forme pour une cellule.
|
|
732
|
+
*
|
|
733
|
+
* Ce qui ne tient pas sur une ligne — un objet, un tableau de sections — n'est
|
|
734
|
+
* pas tronqué mais écarté : une cellule affichant `[object Object]` vaut moins
|
|
735
|
+
* qu'une cellule vide.
|
|
736
|
+
*/
|
|
737
|
+
export declare function formatDocumentValue(value: unknown, type: 'text' | 'boolean' | 'number', invert?: boolean): string;
|
|
738
|
+
export declare function buildPageRows(docs: readonly PageDoc[], config: ResolvedKitConfig, documentColumns?: readonly ResolvedDocumentColumn[]): PageRow[];
|
|
739
|
+
/**
|
|
740
|
+
* `structure` reproduit l'ordre du Studio : les types dans l'ordre où
|
|
741
|
+
* `pageTypes` les déclare, puis les titres. C'est l'ordre par défaut, celui
|
|
742
|
+
* que l'éditeur a déjà en tête en arrivant de la structure.
|
|
743
|
+
*/
|
|
744
|
+
type SortKey = 'structure' | 'title' | 'type' | 'path' | 'status' | 'updatedAt' | 'blockCount';
|
|
745
|
+
type SortDirection = 'asc' | 'desc';
|
|
746
|
+
interface SortOptions {
|
|
747
|
+
/** Ordre de déclaration des types, pour le tri « structure ». */
|
|
748
|
+
typeOrder?: readonly string[];
|
|
749
|
+
}
|
|
750
|
+
export declare function sortRows(rows: readonly PageRow[], key: SortKey, direction: SortDirection, options?: SortOptions): PageRow[];
|
|
751
|
+
interface PageFilters {
|
|
752
|
+
types?: readonly string[];
|
|
753
|
+
statuses?: readonly PageStatus[];
|
|
754
|
+
locales?: readonly string[];
|
|
755
|
+
/** Recherche insensible à la casse et aux accents, sur le titre et le chemin. */
|
|
756
|
+
search?: string;
|
|
757
|
+
}
|
|
758
|
+
export declare function filterRows(rows: readonly PageRow[], filters: PageFilters): PageRow[];
|
|
759
|
+
/** Langues réellement présentes, pour ne proposer que des filtres utiles. */
|
|
760
|
+
export declare function localesInRows(rows: readonly PageRow[]): string[];
|
|
761
|
+
/**
|
|
762
|
+
* Comptage des blocs du page builder, imbriqués compris.
|
|
763
|
+
*
|
|
764
|
+
* Le parcours descend dans tout ce qu'il rencontre (tableaux, objets), parce
|
|
765
|
+
* qu'un bloc conteneur peut porter ses enfants à n'importe quelle profondeur :
|
|
766
|
+
* `section.columns` → `columns[]` → `blocks[]` → `section.cta`.
|
|
767
|
+
*/
|
|
768
|
+
interface BlockOccurrence {
|
|
769
|
+
type: string;
|
|
770
|
+
/** Nombre d'instances, toutes profondeurs confondues. */
|
|
771
|
+
count: number;
|
|
772
|
+
/** Identifiants des documents où le bloc apparaît, sans doublon. */
|
|
773
|
+
documentIds: string[];
|
|
774
|
+
}
|
|
775
|
+
interface OccurrenceInput {
|
|
776
|
+
_id: string;
|
|
777
|
+
/** Contenu du champ page builder. */
|
|
778
|
+
blocks: unknown;
|
|
779
|
+
}
|
|
780
|
+
interface CollectOptions {
|
|
781
|
+
/**
|
|
782
|
+
* Types considérés comme des blocs. Nécessaire : sans cette liste on
|
|
783
|
+
* compterait aussi les objets internes d'un bloc (`faqItem`, `column`,
|
|
784
|
+
* `block`, `span`, `image`...).
|
|
785
|
+
*/
|
|
786
|
+
blockTypes: readonly string[];
|
|
787
|
+
}
|
|
788
|
+
/** Compte les blocs par type sur un ensemble de documents. */
|
|
789
|
+
export declare function collectOccurrences(docs: readonly OccurrenceInput[], options: CollectOptions): Map<string, BlockOccurrence>;
|
|
790
|
+
/**
|
|
791
|
+
* Occurrences de tous les types connus, y compris ceux à zéro — ce sont eux
|
|
792
|
+
* qui intéressent le plus (blocs déclarés mais jamais utilisés).
|
|
793
|
+
*/
|
|
794
|
+
export declare function occurrencesForTypes(docs: readonly OccurrenceInput[], blockTypes: readonly string[]): BlockOccurrence[];
|
|
795
|
+
/** Nombre de blocs de premier niveau d'une page (colonne « blocs » de la liste). */
|
|
796
|
+
export declare function topLevelBlockCount(blocks: unknown): number;
|
|
797
|
+
interface BlockTypeInfo {
|
|
798
|
+
name: string;
|
|
799
|
+
title: string;
|
|
800
|
+
}
|
|
801
|
+
/**
|
|
802
|
+
* Types de blocs autorisés dans le page builder, lus dans le schéma du Studio.
|
|
803
|
+
*
|
|
804
|
+
* Jamais saisis à la main : la liste vient des types déclarés dans le champ
|
|
805
|
+
* `of` du tableau, exactement comme le menu d'insertion la construit. Un bloc
|
|
806
|
+
* ajouté au schéma apparaît donc ici sans toucher au kit.
|
|
807
|
+
*/
|
|
808
|
+
export declare function blockTypesFromSchema(schema: Schema, pageTypes: readonly ResolvedPageType[], pageBuilderField: string): BlockTypeInfo[];
|
|
809
|
+
/**
|
|
810
|
+
* Types de pages déclarés dans la config mais absents du schéma. Une faute de
|
|
811
|
+
* frappe dans `pageTypes` se traduirait sinon par une liste vide et aucune
|
|
812
|
+
* explication.
|
|
813
|
+
*/
|
|
814
|
+
export declare function missingPageTypes(schema: Schema, pageTypes: readonly ResolvedPageType[]): string[];
|
|
815
|
+
/**
|
|
816
|
+
* Types de pages dont le champ page builder est absent du schéma. Ils restent
|
|
817
|
+
* listables, mais leur nombre de blocs sera toujours nul.
|
|
818
|
+
*/
|
|
819
|
+
export declare function pageTypesWithoutBuilder(schema: Schema, pageTypes: readonly ResolvedPageType[], pageBuilderField: string): string[];
|
|
820
|
+
/**
|
|
821
|
+
* Les projections sont préfixées `ncf` pour ne jamais entrer en collision avec
|
|
822
|
+
* un champ du client, quel que soit son schéma.
|
|
823
|
+
*/
|
|
824
|
+
export declare const PROJECTION: {
|
|
825
|
+
readonly title: "ncfTitle";
|
|
826
|
+
readonly slug: "ncfSlug";
|
|
827
|
+
readonly locale: "ncfLocale";
|
|
828
|
+
readonly blockCount: "ncfBlockCount";
|
|
829
|
+
readonly noindex: "ncfNoindex";
|
|
830
|
+
readonly blocks: "ncfBlocks";
|
|
831
|
+
};
|
|
832
|
+
/** Préfixe des projections de données de page, une par colonne déclarée. */
|
|
833
|
+
export declare const DATA_PREFIX = "ncfData_";
|
|
834
|
+
/** Clé de colonne acceptable : elle devient un nom de projection GROQ. */
|
|
835
|
+
export declare const isSafeColumnKey: (key: string) => boolean;
|
|
836
|
+
/** Chemin de champ GROQ acceptable : identifiants séparés par des points. */
|
|
837
|
+
export declare const isSafeFieldPath: (path: string) => boolean;
|
|
838
|
+
/**
|
|
839
|
+
* Requête de la liste des pages : projection légère, sans le contenu du page
|
|
840
|
+
* builder. Seul son cardinal est remonté, pour que 500 pages restent tenables.
|
|
841
|
+
*
|
|
842
|
+
* Les champs titre et slug pouvant différer d'un type à l'autre, ils sont
|
|
843
|
+
* fusionnés par `coalesce` plutôt que projetés type par type.
|
|
844
|
+
*/
|
|
845
|
+
export declare function buildPagesQuery(config: ResolvedKitConfig,
|
|
846
|
+
/** Seules les colonnes réellement affichées sont projetées. */
|
|
847
|
+
documentColumns?: readonly ResolvedDocumentColumn[]): string;
|
|
848
|
+
/**
|
|
849
|
+
* Requête du contenu complet des pages.
|
|
850
|
+
*
|
|
851
|
+
* Elle sert à deux choses qu'aucune projection GROQ ne peut exprimer
|
|
852
|
+
* génériquement : compter des blocs imbriqués à profondeur inconnue, et
|
|
853
|
+
* relever les liens internes où qu'ils se trouvent dans le document. D'où le
|
|
854
|
+
* document entier, la limite explicite, et le fait qu'elle ne parte qu'à
|
|
855
|
+
* l'ouverture de l'outil qui en a besoin.
|
|
856
|
+
*/
|
|
857
|
+
export declare function buildContentsQuery(config: ResolvedKitConfig, limit: number): string;
|
|
858
|
+
/**
|
|
859
|
+
* Sous-ensemble du schéma du Studio dont on a besoin.
|
|
860
|
+
*
|
|
861
|
+
* Déclaré structurellement plutôt qu'importé de `@sanity/types` : le parcours
|
|
862
|
+
* reste une fonction pure, testable sans monter un Studio.
|
|
863
|
+
*/
|
|
864
|
+
interface SchemaTypeLike {
|
|
865
|
+
name?: string;
|
|
866
|
+
title?: string;
|
|
867
|
+
jsonType?: string;
|
|
868
|
+
fields?: SchemaFieldLike[];
|
|
869
|
+
/** Type parent, quand le champ hérite d'un type nommé. */
|
|
870
|
+
type?: SchemaTypeLike;
|
|
871
|
+
}
|
|
872
|
+
interface SchemaFieldLike {
|
|
873
|
+
name: string;
|
|
874
|
+
type?: SchemaTypeLike;
|
|
875
|
+
}
|
|
876
|
+
/** `seo.description` → `seo_description`, utilisable comme nom de projection. */
|
|
877
|
+
export declare function keyForPath(path: string): string;
|
|
878
|
+
interface DeriveOptions {
|
|
879
|
+
/** Chemins déjà représentés ailleurs dans le tableau. */
|
|
880
|
+
exclude?: readonly string[];
|
|
881
|
+
/** Profondeur d'imbrication explorée. 1 couvre `seo.description`. */
|
|
882
|
+
depth?: number;
|
|
883
|
+
}
|
|
884
|
+
/**
|
|
885
|
+
* Colonnes tirées du schéma des types de page.
|
|
886
|
+
*
|
|
887
|
+
* Aucune liste à tenir à jour : ce que le client stocke au niveau de la page
|
|
888
|
+
* est proposé, et lui seul sait ce qu'il veut voir. Seules les valeurs qui
|
|
889
|
+
* tiennent sur une ligne sont retenues — un tableau de sections ou une image
|
|
890
|
+
* n'ont rien à faire dans une cellule.
|
|
891
|
+
*
|
|
892
|
+
* Les types se recouvrent souvent : un même chemin trouvé sur deux types ne
|
|
893
|
+
* donne qu'une colonne, que la requête résoudra par `coalesce`.
|
|
894
|
+
*/
|
|
895
|
+
export declare function deriveDocumentColumns(types: readonly (SchemaTypeLike | undefined)[], options?: DeriveOptions): ResolvedDocumentColumn[];
|
|
896
|
+
/**
|
|
897
|
+
* Comparaison de deux états d'un document.
|
|
898
|
+
*
|
|
899
|
+
* Le diff se calcule ici plutôt que sur le serveur : le kit ne doit rien
|
|
900
|
+
* savoir du schéma d'un client, et une comparaison générique de deux objets
|
|
901
|
+
* JSON n'a besoin de rien d'autre que des deux objets.
|
|
902
|
+
*/
|
|
903
|
+
type ChangeKind = 'added' | 'removed' | 'changed';
|
|
904
|
+
interface Change {
|
|
905
|
+
/** Chemin lisible, ex. `seo.metaDescription` ou `sections[2].title`. */
|
|
906
|
+
path: string;
|
|
907
|
+
kind: ChangeKind;
|
|
908
|
+
before: unknown;
|
|
909
|
+
after: unknown;
|
|
910
|
+
}
|
|
911
|
+
/**
|
|
912
|
+
* Aplatit un document en chemins terminaux.
|
|
913
|
+
*
|
|
914
|
+
* Les tableaux sont indexés par leur `_key` quand il existe — c'est ce que
|
|
915
|
+
* Sanity garantit stable — et par leur position sinon. Réordonner des
|
|
916
|
+
* sections ne doit pas se lire comme si tout leur contenu avait changé.
|
|
917
|
+
*/
|
|
918
|
+
export declare function flatten(value: unknown, prefix?: string, out?: Map<string, unknown>): Map<string, unknown>;
|
|
919
|
+
/**
|
|
920
|
+
* Modifications entre deux états, triées par chemin.
|
|
921
|
+
*
|
|
922
|
+
* Un état absent — création ou suppression — se compare à un objet vide
|
|
923
|
+
* plutôt que de produire un cas particulier : tout devient « ajouté » ou
|
|
924
|
+
* « retiré », ce qui se lit aussi bien.
|
|
925
|
+
*/
|
|
926
|
+
export declare function diffDocuments(before: unknown, after: unknown): Change[];
|
|
927
|
+
/**
|
|
928
|
+
* Résumé d'un changement en une ligne.
|
|
929
|
+
*
|
|
930
|
+
* Les valeurs longues sont coupées : une frise doit se parcourir, pas se
|
|
931
|
+
* lire mot à mot.
|
|
932
|
+
*/
|
|
933
|
+
export declare function summarize(value: unknown, max?: number): string;
|
|
934
|
+
interface Segment {
|
|
935
|
+
text: string;
|
|
936
|
+
kind: 'same' | 'added' | 'removed';
|
|
937
|
+
}
|
|
938
|
+
/**
|
|
939
|
+
* Découpe deux textes en segments communs, ajoutés et retirés.
|
|
940
|
+
*
|
|
941
|
+
* Signaler « ce champ a changé » ne dit pas *ce qui* a changé : sur une meta
|
|
942
|
+
* description, l'œil doit tomber sur les deux mots remplacés, pas relire la
|
|
943
|
+
* phrase entière.
|
|
944
|
+
*
|
|
945
|
+
* Plus longue sous-séquence commune, au mot. Coût quadratique, borné par
|
|
946
|
+
* `limit` : au-delà, on rend les deux textes en bloc plutôt que de faire
|
|
947
|
+
* ramer le Studio sur un champ de dix mille mots.
|
|
948
|
+
*/
|
|
949
|
+
export declare function diffWords(before: string, after: string, limit?: number): Segment[];
|
|
950
|
+
/** Une comparaison mot à mot n'a de sens qu'entre deux textes. */
|
|
951
|
+
export declare const isTextChange: (before: unknown, after: unknown) => boolean;
|
|
952
|
+
/**
|
|
953
|
+
* Ce que l'aperçu donne à voir.
|
|
954
|
+
*
|
|
955
|
+
* `drafts` montre le contenu tel qu'il sortira après publication — c'est la
|
|
956
|
+
* question que se pose un relecteur. `published` montre ce que voit le public
|
|
957
|
+
* aujourd'hui.
|
|
958
|
+
*/
|
|
959
|
+
type PreviewPerspective = 'drafts' | 'published';
|
|
960
|
+
export declare const PERSPECTIVES: {
|
|
961
|
+
id: PreviewPerspective;
|
|
962
|
+
label: string;
|
|
963
|
+
hint: string;
|
|
964
|
+
}[];
|
|
965
|
+
/**
|
|
966
|
+
* URL d'une page sur un front donné.
|
|
967
|
+
*
|
|
968
|
+
* L'environnement porte le code, le chemin porte la page. Changer
|
|
969
|
+
* d'environnement ne change donc jamais le chemin : c'est la même page,
|
|
970
|
+
* rendue par une autre version du site.
|
|
971
|
+
*/
|
|
972
|
+
export declare function urlOn(environment: NcfEnvironment | null, path: string | null): string | null;
|
|
973
|
+
interface PresentationOptions {
|
|
974
|
+
/** Front à charger dans l'aperçu. */
|
|
975
|
+
environment?: NcfEnvironment | null;
|
|
976
|
+
perspective?: PreviewPerspective;
|
|
977
|
+
}
|
|
978
|
+
/**
|
|
979
|
+
* Liens internes au Studio.
|
|
980
|
+
*
|
|
981
|
+
* Ouvrir une page doit mener à **Presentation**, pas à la structure : on veut
|
|
982
|
+
* voir la page, pas son formulaire. Le tool attend l'URL du front en clair
|
|
983
|
+
* dans le paramètre `preview`, et la perspective dans `perspective`.
|
|
984
|
+
*/
|
|
985
|
+
export declare function presentationPath(url: string | null | undefined, options?: PresentationOptions): string | null;
|
|
986
|
+
/** Lien d'édition classique, pour les cas où l'on veut le formulaire. */
|
|
987
|
+
export declare function editIntentPath(id: string, type: string): string;
|
|
988
|
+
/**
|
|
989
|
+
* Origines à autoriser dans `presentationTool({allowOrigins})`.
|
|
990
|
+
*
|
|
991
|
+
* Presentation refuse de dialoguer avec un front dont l'origine n'est pas
|
|
992
|
+
* déclarée : sans cela, basculer vers une préproduction donnerait un aperçu
|
|
993
|
+
* muet, sans édition visuelle ni surlignage.
|
|
994
|
+
*
|
|
995
|
+
* ```ts
|
|
996
|
+
* presentationTool({allowOrigins: ncfAllowedOrigins(kitConfig), previewUrl: …})
|
|
997
|
+
* ```
|
|
998
|
+
*/
|
|
999
|
+
export declare function ncfAllowedOrigins(config: {
|
|
1000
|
+
environments?: NcfEnvironment[];
|
|
1001
|
+
previewUrl?: string | null;
|
|
1002
|
+
}): string[];
|
|
1003
|
+
/** Identifiant de l'environnement libre, saisi à la volée. */
|
|
1004
|
+
export declare const CUSTOM_ENVIRONMENT_ID = "ncf-custom";
|
|
1005
|
+
/**
|
|
1006
|
+
* Environnement bâti depuis une URL collée.
|
|
1007
|
+
*
|
|
1008
|
+
* Les préversions sont innombrables et éphémères — une par branche, parfois
|
|
1009
|
+
* une par commit. Les déclarer d'avance serait vain : on colle l'adresse du
|
|
1010
|
+
* déploiement qu'on a sous les yeux.
|
|
1011
|
+
*
|
|
1012
|
+
* Rend `null` si l'URL n'est pas exploitable, plutôt qu'un environnement qui
|
|
1013
|
+
* chargerait une page blanche.
|
|
1014
|
+
*/
|
|
1015
|
+
export declare function customEnvironment(raw: string): NcfEnvironment | null;
|
|
1016
|
+
interface PreviewTargetState {
|
|
1017
|
+
environments: NcfEnvironment[];
|
|
1018
|
+
environment: NcfEnvironment | null;
|
|
1019
|
+
environmentId: string | null;
|
|
1020
|
+
perspective: PreviewPerspective;
|
|
1021
|
+
setEnvironment: (id: string) => void;
|
|
1022
|
+
/**
|
|
1023
|
+
* Cible une adresse collée à la volée. Chaîne vide : retour au premier
|
|
1024
|
+
* environnement déclaré.
|
|
1025
|
+
*/
|
|
1026
|
+
setCustomUrl: (url: string) => boolean;
|
|
1027
|
+
customUrl: string | null;
|
|
1028
|
+
setPerspective: (perspective: PreviewPerspective) => void;
|
|
1029
|
+
/** Chemin Studio vers Presentation pour une page, selon la cible choisie. */
|
|
1030
|
+
pathFor: (url: string | null) => string | null;
|
|
1031
|
+
/** URL de la page sur l'environnement choisi, pour l'ouvrir hors du Studio. */
|
|
1032
|
+
siteUrlFor: (url: string | null) => string | null;
|
|
1033
|
+
}
|
|
1034
|
+
export declare function usePreviewTarget(): PreviewTargetState;
|
|
1035
|
+
/**
|
|
1036
|
+
* Bascule brouillons / en ligne, posée dans l'aperçu lui-même.
|
|
1037
|
+
*
|
|
1038
|
+
* Le choix se fait là où l'on regarde. Le mettre ailleurs — dans une autre
|
|
1039
|
+
* barre, dans un autre onglet — obligerait à sortir de la page pour changer
|
|
1040
|
+
* ce qu'on y voit, et on reviendrait sans savoir ce qu'on regarde.
|
|
1041
|
+
*
|
|
1042
|
+
* Presentation lit la perspective dans l'URL du Studio : on l'y écrit plutôt
|
|
1043
|
+
* que d'en tenir une copie, de sorte que l'adresse partagée montre la même
|
|
1044
|
+
* chose à qui l'ouvre.
|
|
1045
|
+
*/
|
|
1046
|
+
export declare function NcfPreviewHeader(props: PreviewHeaderProps): import("react").JSX.Element;
|
|
1047
|
+
/**
|
|
1048
|
+
* À passer à `presentationTool` pour que la bascule apparaisse dans l'aperçu :
|
|
1049
|
+
*
|
|
1050
|
+
* ```ts
|
|
1051
|
+
* presentationTool({components: ncfPreviewComponents(), previewUrl: …})
|
|
1052
|
+
* ```
|
|
1053
|
+
*/
|
|
1054
|
+
export declare function ncfPreviewComponents(): {
|
|
1055
|
+
unstable_header: {
|
|
1056
|
+
component: typeof NcfPreviewHeader;
|
|
1057
|
+
};
|
|
1058
|
+
};
|
|
1059
|
+
/**
|
|
1060
|
+
* Appels au service du kit.
|
|
1061
|
+
*
|
|
1062
|
+
* Deux principes tiennent ce fichier :
|
|
1063
|
+
*
|
|
1064
|
+
* - **On échoue en silence, jamais en bloquant.** Une panne réseau ou une
|
|
1065
|
+
* indisponibilité du service ne doit pas empêcher un éditeur de travailler.
|
|
1066
|
+
* Le Studio d'un client ne dépend pas de notre disponibilité.
|
|
1067
|
+
* - **On n'envoie rien du contenu.** Le signalement de présence porte un
|
|
1068
|
+
* identifiant de projet, un dataset, un hôte et une version. Rien d'autre.
|
|
1069
|
+
*/
|
|
1070
|
+
type ProjectStatus = 'unregistered' | 'active' | 'suspended' | 'expired' | 'blocked';
|
|
1071
|
+
interface Registration {
|
|
1072
|
+
status: ProjectStatus;
|
|
1073
|
+
expiresAt?: string | null;
|
|
1074
|
+
}
|
|
1075
|
+
interface HistoryEvent {
|
|
1076
|
+
id: number;
|
|
1077
|
+
document_id: string;
|
|
1078
|
+
document_type: string;
|
|
1079
|
+
operation: 'create' | 'update' | 'delete';
|
|
1080
|
+
/** Vrai quand le changement porte sur le brouillon, pas sur la version en ligne. */
|
|
1081
|
+
is_draft: boolean;
|
|
1082
|
+
actor_id: string | null;
|
|
1083
|
+
actor_name: string | null;
|
|
1084
|
+
occurred_at: string;
|
|
1085
|
+
revision: string | null;
|
|
1086
|
+
}
|
|
1087
|
+
interface HistoryDetail {
|
|
1088
|
+
current: HistoryEvent & {
|
|
1089
|
+
snapshot: Record<string, unknown> | null;
|
|
1090
|
+
};
|
|
1091
|
+
previous: (HistoryEvent & {
|
|
1092
|
+
snapshot: Record<string, unknown> | null;
|
|
1093
|
+
}) | null;
|
|
1094
|
+
}
|
|
1095
|
+
/**
|
|
1096
|
+
* Signale la présence de ce Studio et rend son statut.
|
|
1097
|
+
*
|
|
1098
|
+
* Rend `null` si le service ne répond pas : l'appelant traitera ce cas comme
|
|
1099
|
+
* « rien à signaler », et surtout pas comme un refus.
|
|
1100
|
+
*/
|
|
1101
|
+
export declare function announce(endpoint: string, payload: {
|
|
1102
|
+
projectId: string;
|
|
1103
|
+
dataset: string;
|
|
1104
|
+
host: string;
|
|
1105
|
+
version: string;
|
|
1106
|
+
}, signal?: AbortSignal): Promise<Registration | null>;
|
|
1107
|
+
export declare function fetchTimeline(endpoint: string, key: string, options?: {
|
|
1108
|
+
documentId?: string;
|
|
1109
|
+
limit?: number;
|
|
1110
|
+
before?: string;
|
|
1111
|
+
}, signal?: AbortSignal): Promise<{
|
|
1112
|
+
events: HistoryEvent[];
|
|
1113
|
+
hasMore: boolean;
|
|
1114
|
+
retentionDays: number;
|
|
1115
|
+
}>;
|
|
1116
|
+
export declare function fetchDetail(endpoint: string, key: string, eventId: number, signal?: AbortSignal): Promise<HistoryDetail>;
|
|
1117
|
+
interface HistoryState {
|
|
1118
|
+
events: HistoryEvent[];
|
|
1119
|
+
loading: boolean;
|
|
1120
|
+
/** Message prêt à afficher, déjà traduit depuis le code du service. */
|
|
1121
|
+
error: string | null;
|
|
1122
|
+
hasMore: boolean;
|
|
1123
|
+
loadMore: () => void;
|
|
1124
|
+
refresh: () => void;
|
|
1125
|
+
}
|
|
1126
|
+
/**
|
|
1127
|
+
* Frise du journal, la plus récente d'abord.
|
|
1128
|
+
*
|
|
1129
|
+
* Paginée par curseur et non par décalage : des événements arrivent pendant
|
|
1130
|
+
* qu'on lit, et un décalage ferait sauter des lignes.
|
|
1131
|
+
*/
|
|
1132
|
+
export declare function useHistory(documentId?: string): HistoryState;
|
|
1133
|
+
/**
|
|
1134
|
+
* Signale ce Studio au service du kit, une fois par montage.
|
|
1135
|
+
*
|
|
1136
|
+
* C'est ce qui permet de savoir quels projets utilisent le kit. Ce qui part :
|
|
1137
|
+
* identifiant de projet Sanity, dataset, hôte du Studio, version du kit.
|
|
1138
|
+
* Aucun contenu, aucune identité d'éditeur.
|
|
1139
|
+
*
|
|
1140
|
+
* `serviceEndpoint: false` en configuration coupe complètement cet appel.
|
|
1141
|
+
*
|
|
1142
|
+
* En cas d'échec — réseau coupé, service indisponible — on rend `null` et
|
|
1143
|
+
* rien ne change : le Studio d'un client ne doit pas dépendre de notre
|
|
1144
|
+
* disponibilité.
|
|
1145
|
+
*/
|
|
1146
|
+
export declare function useRegistration(): Registration | null;
|
|
1147
|
+
/**
|
|
1148
|
+
* Nom de l'auteur d'un changement.
|
|
1149
|
+
*
|
|
1150
|
+
* Le webhook ne transmet qu'un identifiant — `identity()` en GROQ. Le résoudre
|
|
1151
|
+
* ici plutôt qu'à l'ingestion évite de stocker des noms qui se périment et
|
|
1152
|
+
* d'avoir à détenir un jeton Sanity par client.
|
|
1153
|
+
*/
|
|
1154
|
+
export declare function ActorName(props: {
|
|
1155
|
+
actorId: string | null;
|
|
1156
|
+
actorName: string | null;
|
|
1157
|
+
}): import("react").JSX.Element;
|
|
1158
|
+
/**
|
|
1159
|
+
* Version du kit, rapportée au service pour savoir quels projets tournent sur
|
|
1160
|
+
* quelle version. Tenue à jour avec `package.json`.
|
|
1161
|
+
*/
|
|
1162
|
+
export declare const KIT_VERSION = "2.0.0";
|
|
1163
|
+
/**
|
|
1164
|
+
* Données de la page proposées comme colonnes.
|
|
1165
|
+
*
|
|
1166
|
+
* Tirées du schéma du client : le Studio le connaît déjà, et aucune liste
|
|
1167
|
+
* tenue à la main ne suivrait les schémas de tous les projets. `documentColumns`
|
|
1168
|
+
* en configuration vient compléter, pour ce que le parcours ne sait pas
|
|
1169
|
+
* exprimer — un chemin profond, ou plusieurs chemins fusionnés.
|
|
1170
|
+
*
|
|
1171
|
+
* Les chemins déjà représentés par une colonne de base — titre, slug, langue,
|
|
1172
|
+
* page builder — sont écartés : les voir deux fois n'apprend rien.
|
|
1173
|
+
*/
|
|
1174
|
+
export declare function useDocumentColumns(): ResolvedDocumentColumn[];
|
|
1175
|
+
interface BoardNode {
|
|
1176
|
+
/** Identifiant du document, réutilisé comme identifiant de nœud. */
|
|
1177
|
+
id: string;
|
|
1178
|
+
row: PageRow;
|
|
1179
|
+
/** Nombre de pages qui pointent vers celle-ci. */
|
|
1180
|
+
incoming: number;
|
|
1181
|
+
/** Nombre de pages vers lesquelles elle pointe. */
|
|
1182
|
+
outgoing: number;
|
|
1183
|
+
/** Distance depuis une page sans lien entrant. Sert au placement de repli. */
|
|
1184
|
+
depth: number;
|
|
1185
|
+
}
|
|
1186
|
+
interface BoardEdge {
|
|
1187
|
+
id: string;
|
|
1188
|
+
source: string;
|
|
1189
|
+
target: string;
|
|
1190
|
+
}
|
|
1191
|
+
interface BoardGraph {
|
|
1192
|
+
nodes: BoardNode[];
|
|
1193
|
+
edges: BoardEdge[];
|
|
1194
|
+
/** Pages sans chemin calculable : elles n'ont pas d'adresse à relier. */
|
|
1195
|
+
unplaced: PageRow[];
|
|
1196
|
+
/** Chemins portés par plusieurs pages, à signaler plutôt qu'à masquer. */
|
|
1197
|
+
duplicatePaths: string[];
|
|
1198
|
+
/** Pages sans aucun lien entrant ni sortant. */
|
|
1199
|
+
orphans: string[];
|
|
1200
|
+
}
|
|
1201
|
+
/**
|
|
1202
|
+
* Graphe des liens réels entre pages.
|
|
1203
|
+
*
|
|
1204
|
+
* Une arête existe quand le contenu d'une page pointe vers une autre, par
|
|
1205
|
+
* chemin (`/contact`) ou par référence. La hiérarchie des slugs n'intervient
|
|
1206
|
+
* pas : deux pages voisines dans l'URL mais jamais liées restent séparées, et
|
|
1207
|
+
* une page que rien ne lie apparaît isolée — c'est une information, pas un défaut.
|
|
1208
|
+
*/
|
|
1209
|
+
export declare function buildLinkGraph(rows: readonly PageRow[], contents: ReadonlyMap<string, unknown>): BoardGraph;
|
|
1210
|
+
/**
|
|
1211
|
+
* Position, taille et étiquette d'un nœud, telles qu'enregistrées.
|
|
1212
|
+
*
|
|
1213
|
+
* `x` et `y` sont **absents** tant que le nœud n'a pas été déplacé à la main.
|
|
1214
|
+
* Les inventer à zéro faisait passer « jamais positionné » pour « positionné à
|
|
1215
|
+
* l'origine », et toutes ces pages s'empilaient au coin du canvas.
|
|
1216
|
+
*/
|
|
1217
|
+
interface NodeLayout {
|
|
1218
|
+
documentId: string;
|
|
1219
|
+
x?: number;
|
|
1220
|
+
y?: number;
|
|
1221
|
+
/** Taille choisie à la main, absente tant que le nœud n'a pas été redimensionné. */
|
|
1222
|
+
width?: number;
|
|
1223
|
+
height?: number;
|
|
1224
|
+
/** Identifiant d'étiquette de suivi, ex. 'a-relire'. */
|
|
1225
|
+
tag?: string;
|
|
1226
|
+
/** Valeurs des champs de gestion interne, par identifiant de champ. */
|
|
1227
|
+
fields?: Record<string, string>;
|
|
1228
|
+
}
|
|
1229
|
+
/**
|
|
1230
|
+
* Note ou forme posée sur un canvas, derrière les nœuds. Sert à commenter une
|
|
1231
|
+
* zone du board ou de la carte sans toucher au contenu.
|
|
1232
|
+
*/
|
|
1233
|
+
interface Annotation {
|
|
1234
|
+
id: string;
|
|
1235
|
+
/** Canvas auquel la note appartient. */
|
|
1236
|
+
scope: 'pages' | 'sections';
|
|
1237
|
+
kind: 'text' | 'rect';
|
|
1238
|
+
x: number;
|
|
1239
|
+
y: number;
|
|
1240
|
+
width: number;
|
|
1241
|
+
height: number;
|
|
1242
|
+
text?: string;
|
|
1243
|
+
color?: string;
|
|
1244
|
+
}
|
|
1245
|
+
/** Position manuelle d'une section sur la carte des composants. */
|
|
1246
|
+
interface SectionLayout {
|
|
1247
|
+
blockName: string;
|
|
1248
|
+
x: number;
|
|
1249
|
+
y: number;
|
|
1250
|
+
}
|
|
1251
|
+
/** Compatibilité : une position seule reste un `NodeLayout` valide. */
|
|
1252
|
+
type NodePosition = NodeLayout;
|
|
1253
|
+
interface Positioned {
|
|
1254
|
+
id: string;
|
|
1255
|
+
position: {
|
|
1256
|
+
x: number;
|
|
1257
|
+
y: number;
|
|
1258
|
+
};
|
|
1259
|
+
}
|
|
1260
|
+
/**
|
|
1261
|
+
* Applique les positions enregistrées par-dessus celles du placement
|
|
1262
|
+
* automatique. Une page déplacée à la main garde sa place ; une page ajoutée
|
|
1263
|
+
* depuis prend celle que le layout lui a calculée.
|
|
1264
|
+
*/
|
|
1265
|
+
export declare function applySavedPositions(computed: readonly Positioned[], saved: readonly NodeLayout[]): Positioned[];
|
|
1266
|
+
/** Ne conserve que les entrées de pages encore existantes. */
|
|
1267
|
+
export declare function pruneSavedPositions(saved: readonly NodeLayout[], existingIds: readonly string[]): NodeLayout[];
|
|
1268
|
+
/** Fusionne une modification dans la disposition, sans perdre le reste. */
|
|
1269
|
+
export declare function upsertLayout(saved: readonly NodeLayout[], documentId: string, patch: Partial<Omit<NodeLayout, 'documentId'>>): NodeLayout[];
|
|
1270
|
+
/**
|
|
1271
|
+
* Détection des liens réels entre pages.
|
|
1272
|
+
*
|
|
1273
|
+
* Deux formes sont reconnues, sans rien supposer du schéma du client :
|
|
1274
|
+
*
|
|
1275
|
+
* - les **chaînes de chemin** (`href: "/contact"`), convention du starter, y
|
|
1276
|
+
* compris dans les annotations de texte riche ;
|
|
1277
|
+
* - les **références Sanity** (`_ref`) vers un document de page, pour les
|
|
1278
|
+
* projets qui lient par référence.
|
|
1279
|
+
*
|
|
1280
|
+
* Un chemin n'est retenu que s'il correspond à une page connue : les liens
|
|
1281
|
+
* externes, les ancres, `mailto:` et les chemins morts disparaissent d'eux-mêmes.
|
|
1282
|
+
*/
|
|
1283
|
+
/**
|
|
1284
|
+
* Normalise une valeur en chemin interne comparable, ou `null`.
|
|
1285
|
+
* `/contact?x=1#bas` → `/contact` · `/services/` → `/services`
|
|
1286
|
+
*/
|
|
1287
|
+
export declare function normalizeInternalPath(value: unknown): string | null;
|
|
1288
|
+
interface CollectedLinks {
|
|
1289
|
+
paths: string[];
|
|
1290
|
+
refs: string[];
|
|
1291
|
+
}
|
|
1292
|
+
/**
|
|
1293
|
+
* Parcourt une valeur de document et relève tout ce qui ressemble à un lien
|
|
1294
|
+
* interne. Ne filtre pas sur le nom du champ : un client peut appeler son
|
|
1295
|
+
* champ `href`, `url`, `lien` ou le nicher dans du texte riche.
|
|
1296
|
+
*/
|
|
1297
|
+
export declare function collectLinks(value: unknown): CollectedLinks;
|
|
1298
|
+
interface SectionMapNode {
|
|
1299
|
+
id: string;
|
|
1300
|
+
block: BlockTypeInfo;
|
|
1301
|
+
occurrence: BlockOccurrence;
|
|
1302
|
+
position: {
|
|
1303
|
+
x: number;
|
|
1304
|
+
y: number;
|
|
1305
|
+
};
|
|
1306
|
+
size: number;
|
|
1307
|
+
}
|
|
1308
|
+
/** Ordre de placement des tuiles. */
|
|
1309
|
+
type SectionOrder = 'type' | 'usage' | 'unused';
|
|
1310
|
+
interface SectionsMapOptions {
|
|
1311
|
+
/** Défaut : par type, pour que chaque bloc garde toujours la même place. */
|
|
1312
|
+
order?: SectionOrder;
|
|
1313
|
+
/** Côté d'une tuile pour un bloc jamais utilisé. */
|
|
1314
|
+
minSize?: number;
|
|
1315
|
+
/** Côté d'une tuile pour le bloc le plus utilisé. */
|
|
1316
|
+
maxSize?: number;
|
|
1317
|
+
/** Nombre de colonnes de la grille. */
|
|
1318
|
+
columns?: number;
|
|
1319
|
+
gap?: number;
|
|
1320
|
+
}
|
|
1321
|
+
/**
|
|
1322
|
+
* Disposition de la carte des sections.
|
|
1323
|
+
*
|
|
1324
|
+
* Grille ordonnée par usage décroissant, tuiles dimensionnées par le nombre
|
|
1325
|
+
* d'occurrences : ce qui structure le site saute aux yeux, ce qui ne sert
|
|
1326
|
+
* jamais se voit tout autant par sa petitesse.
|
|
1327
|
+
*/
|
|
1328
|
+
export declare function layoutSectionsMap(blocks: readonly BlockTypeInfo[], occurrences: readonly BlockOccurrence[], options?: SectionsMapOptions): SectionMapNode[];
|
|
1329
|
+
/**
|
|
1330
|
+
* URL de la capture d'une page.
|
|
1331
|
+
*
|
|
1332
|
+
* Le nom de fichier est dérivé du chemin, pas du titre : c'est la seule clé
|
|
1333
|
+
* stable entre le Studio et le script qui produit les captures.
|
|
1334
|
+
* `/services/plomberie` → `services-plomberie` · `/` → `home`
|
|
1335
|
+
*/
|
|
1336
|
+
export declare function slugKey(path: string): string;
|
|
1337
|
+
interface ThumbnailInput {
|
|
1338
|
+
path: string | null;
|
|
1339
|
+
locale?: string | null;
|
|
1340
|
+
id: string;
|
|
1341
|
+
}
|
|
1342
|
+
/**
|
|
1343
|
+
* Résout le gabarit. Renvoie `null` si aucune capture n'est configurée ou si
|
|
1344
|
+
* la page n'a pas de chemin : le board retombe alors sur l'iframe en direct.
|
|
1345
|
+
*/
|
|
1346
|
+
export declare function pageThumbnailUrl(template: string | null, previewUrl: string | null, input: ThumbnailInput): string | null;
|
|
1347
|
+
/** Critère de regroupement de la liste des pages. */
|
|
1348
|
+
type GroupBy = 'none' | 'tag' | 'type' | 'status' | 'indexation' | `field:${string}`;
|
|
1349
|
+
interface RowGroup {
|
|
1350
|
+
/** Valeur brute du critère, ou `''` quand elle n'est pas renseignée. */
|
|
1351
|
+
key: string;
|
|
1352
|
+
label: string;
|
|
1353
|
+
/** Couleur associée, pour les étiquettes et les choix qui en ont une. */
|
|
1354
|
+
color?: string;
|
|
1355
|
+
rows: PageRow[];
|
|
1356
|
+
}
|
|
1357
|
+
export declare const UNSET_LABEL = "Non renseigné";
|
|
1358
|
+
interface GroupOptions {
|
|
1359
|
+
/** Disposition enregistrée, qui porte étiquettes et champs internes. */
|
|
1360
|
+
meta: ReadonlyMap<string, NodeLayout>;
|
|
1361
|
+
tags: readonly NcfBoardTag[];
|
|
1362
|
+
fields: readonly NcfInternalField[];
|
|
1363
|
+
}
|
|
1364
|
+
/** Valeur du critère pour une ligne. Chaîne vide = non renseigné. */
|
|
1365
|
+
export declare function groupValue(row: PageRow, groupBy: GroupBy, options: GroupOptions): string;
|
|
1366
|
+
/**
|
|
1367
|
+
* Regroupe les lignes selon le critère choisi.
|
|
1368
|
+
*
|
|
1369
|
+
* L'ordre des groupes suit celui de la configuration (étiquettes, options
|
|
1370
|
+
* d'un champ) pour rester stable d'une visite à l'autre, et le groupe « non
|
|
1371
|
+
* renseigné » ferme la marche : c'est une absence, pas une catégorie.
|
|
1372
|
+
*/
|
|
1373
|
+
export declare function groupPageRows(rows: readonly PageRow[], groupBy: GroupBy, options: GroupOptions): RowGroup[];
|
|
1374
|
+
/** Critère qui donne sa couleur à une page. */
|
|
1375
|
+
type ColorBy = 'tag' | 'status' | `field:${string}`;
|
|
1376
|
+
/** Couleurs des statuts, alignées sur les tons des badges. */
|
|
1377
|
+
export declare const STATUS_COLORS: Record<PageRow['status'], string>;
|
|
1378
|
+
/**
|
|
1379
|
+
* Applique une opacité à une couleur hexadécimale.
|
|
1380
|
+
*
|
|
1381
|
+
* Le fond d'une carte doit rester très pâle : à pleine saturation, le texte
|
|
1382
|
+
* du Studio devient illisible dans les deux thèmes.
|
|
1383
|
+
*/
|
|
1384
|
+
export declare function withAlpha(color: string, alpha: number): string;
|
|
1385
|
+
/**
|
|
1386
|
+
* Couleur stable déduite d'une valeur libre. Deux responsables différents
|
|
1387
|
+
* reçoivent deux teintes différentes, et la même valeur donne toujours la
|
|
1388
|
+
* même couleur d'une session à l'autre.
|
|
1389
|
+
*/
|
|
1390
|
+
export declare function colorFromString(value: string): string;
|
|
1391
|
+
/**
|
|
1392
|
+
* Ramène un critère devenu invalide sur l'étiquette. Supprimer la colonne qui
|
|
1393
|
+
* sert à colorer laisserait sinon le sélecteur sur une valeur inexistante.
|
|
1394
|
+
*/
|
|
1395
|
+
export declare function resolveColorBy(colorBy: ColorBy, fields: readonly {
|
|
1396
|
+
id: string;
|
|
1397
|
+
}[]): ColorBy;
|
|
1398
|
+
interface ColorOptions {
|
|
1399
|
+
meta: ReadonlyMap<string, NodeLayout>;
|
|
1400
|
+
tags: readonly NcfBoardTag[];
|
|
1401
|
+
fields: readonly NcfInternalField[];
|
|
1402
|
+
}
|
|
1403
|
+
interface RowColor {
|
|
1404
|
+
color: string | null;
|
|
1405
|
+
label: string | null;
|
|
1406
|
+
}
|
|
1407
|
+
/** Couleur et libellé d'une page selon le critère choisi. */
|
|
1408
|
+
export declare function colorForRow(row: PageRow, colorBy: ColorBy, options: ColorOptions): RowColor;
|
|
1409
|
+
/**
|
|
1410
|
+
* Colonnes de gestion interne effectives.
|
|
1411
|
+
*
|
|
1412
|
+
* Tant que personne n'y a touché, la configuration fournit le jeu de départ.
|
|
1413
|
+
* Une fois réglées, celles du document font foi — y compris quand il n'en
|
|
1414
|
+
* reste aucune, sinon supprimer la dernière les ferait toutes revenir.
|
|
1415
|
+
*
|
|
1416
|
+
* Toutes les vues doivent passer par ici : la liste, son regroupement et le
|
|
1417
|
+
* board doivent proposer exactement les mêmes colonnes.
|
|
1418
|
+
*/
|
|
1419
|
+
export declare function useInternalColumns(): NcfInternalField[];
|
|
1420
|
+
/**
|
|
1421
|
+
* Identifiant technique dérivé du nom saisi. Stable et lisible dans le
|
|
1422
|
+
* document, contrairement à un identifiant aléatoire.
|
|
1423
|
+
* « Rôle de la page » → `role-de-la-page`
|
|
1424
|
+
*/
|
|
1425
|
+
export declare function columnId(label: string): string;
|
|
1426
|
+
/** Identifiant unique parmi ceux déjà pris, en suffixant si besoin. */
|
|
1427
|
+
export declare function uniqueColumnId(label: string, taken: readonly string[]): string;
|
|
1428
|
+
interface AddColumnInput {
|
|
1429
|
+
label: string;
|
|
1430
|
+
type?: 'text' | 'select';
|
|
1431
|
+
options?: NcfInternalFieldOption[];
|
|
1432
|
+
}
|
|
1433
|
+
/** Ajoute une colonne en fin de liste. Un nom vide est refusé. */
|
|
1434
|
+
export declare function addColumn(columns: readonly NcfInternalField[], input: AddColumnInput): NcfInternalField[];
|
|
1435
|
+
/**
|
|
1436
|
+
* Renomme une colonne sans toucher à son identifiant : les valeurs déjà
|
|
1437
|
+
* saisies y sont rattachées.
|
|
1438
|
+
*/
|
|
1439
|
+
export declare function renameColumn(columns: readonly NcfInternalField[], id: string, label: string): NcfInternalField[];
|
|
1440
|
+
export declare function removeColumn(columns: readonly NcfInternalField[], id: string): NcfInternalField[];
|
|
1441
|
+
/** Déplace une colonne, pour réordonner le tableau. */
|
|
1442
|
+
export declare function moveColumn(columns: readonly NcfInternalField[], id: string, delta: number): NcfInternalField[];
|
|
1443
|
+
/** Ajoute un choix à une colonne de type liste. */
|
|
1444
|
+
export declare function addColumnOption(columns: readonly NcfInternalField[], id: string, label: string): NcfInternalField[];
|
|
1445
|
+
interface AnnotationsState {
|
|
1446
|
+
annotations: Annotation[];
|
|
1447
|
+
add: (kind: Annotation['kind'], position: {
|
|
1448
|
+
x: number;
|
|
1449
|
+
y: number;
|
|
1450
|
+
}) => void;
|
|
1451
|
+
update: (id: string, patch: Partial<Annotation>) => void;
|
|
1452
|
+
remove: (id: string) => void;
|
|
1453
|
+
}
|
|
1454
|
+
/**
|
|
1455
|
+
* Notes et formes d'un canvas. Elles sont stockées avec le reste de la
|
|
1456
|
+
* disposition, filtrées par `scope` : le board des pages et la carte des
|
|
1457
|
+
* sections ne partagent pas leurs annotations.
|
|
1458
|
+
*/
|
|
1459
|
+
export declare function useAnnotations(scope: Annotation['scope']): AnnotationsState;
|
|
1460
|
+
/** Gabarit d'un nœud en vue arborescence. Doit rester synchrone avec PageNode. */
|
|
1461
|
+
export declare const NODE_WIDTH = 220;
|
|
1462
|
+
export declare const NODE_HEIGHT = 168;
|
|
1463
|
+
/** Gabarit compact de la vue cerveau : une pastille, pas une carte. */
|
|
1464
|
+
export declare const BRAIN_NODE_SIZE = 56;
|
|
1465
|
+
type LayoutMode = 'tree' | 'brain';
|
|
1466
|
+
interface LayoutOptions {
|
|
1467
|
+
mode: LayoutMode;
|
|
1468
|
+
/** Tailles manuelles par nœud, pour que le placement en tienne compte. */
|
|
1469
|
+
sizes?: ReadonlyMap<string, {
|
|
1470
|
+
width: number;
|
|
1471
|
+
height: number;
|
|
1472
|
+
}>;
|
|
1473
|
+
/** Des captures sont disponibles : les nœuds passent en portrait. */
|
|
1474
|
+
withScreenshots?: boolean;
|
|
1475
|
+
}
|
|
1476
|
+
export declare function defaultNodeSize(mode: LayoutMode, withScreenshots?: boolean): {
|
|
1477
|
+
width: number;
|
|
1478
|
+
height: number;
|
|
1479
|
+
};
|
|
1480
|
+
/**
|
|
1481
|
+
* Placement automatique. elkjs pèse 1,5 Mo : il est importé à la demande et
|
|
1482
|
+
* jamais au chargement du Studio.
|
|
1483
|
+
*/
|
|
1484
|
+
export declare function layoutGraph(nodes: readonly BoardNode[], edges: readonly BoardEdge[], options: LayoutOptions): Promise<Positioned[]>;
|
|
1485
|
+
/**
|
|
1486
|
+
* Placement de repli, sans elkjs : une grille par profondeur. Sert quand le
|
|
1487
|
+
* calcul échoue, pour que le board affiche quand même quelque chose de lisible
|
|
1488
|
+
* plutôt qu'un tas de nœuds empilés à l'origine.
|
|
1489
|
+
*/
|
|
1490
|
+
export declare function fallbackLayout(nodes: readonly BoardNode[], mode?: LayoutMode, withScreenshots?: boolean): Positioned[];
|
|
1491
|
+
interface BoardLayoutState {
|
|
1492
|
+
layout: NodeLayout[];
|
|
1493
|
+
/** Positions manuelles des sections sur la carte des composants. */
|
|
1494
|
+
sections: SectionLayout[];
|
|
1495
|
+
sectionsByName: Map<string, SectionLayout>;
|
|
1496
|
+
/**
|
|
1497
|
+
* Colonnes de gestion interne. Vides tant que personne n'en a créé : c'est
|
|
1498
|
+
* alors la configuration qui fournit le jeu de départ.
|
|
1499
|
+
*/
|
|
1500
|
+
columns: NcfInternalField[];
|
|
1501
|
+
saveColumns: (next: readonly NcfInternalField[]) => void;
|
|
1502
|
+
/**
|
|
1503
|
+
* Vrai dès que quelqu'un a touché aux colonnes. Sans ce marqueur, supprimer
|
|
1504
|
+
* la dernière colonne ferait réapparaître celles de la configuration.
|
|
1505
|
+
*/
|
|
1506
|
+
columnsSet: boolean;
|
|
1507
|
+
/** Notes et formes posées sur les canvas. */
|
|
1508
|
+
annotations: Annotation[];
|
|
1509
|
+
saveAnnotations: (next: readonly Annotation[]) => void;
|
|
1510
|
+
/** Accès direct par identifiant de page, pour le rendu des nœuds. */
|
|
1511
|
+
byId: Map<string, NodeLayout>;
|
|
1512
|
+
loading: boolean;
|
|
1513
|
+
/** Erreur d'enregistrement : l'utilisateur doit savoir que rien n'est gardé. */
|
|
1514
|
+
saveError: Error | null;
|
|
1515
|
+
/** Enregistre des positions, en oubliant celles des pages disparues. */
|
|
1516
|
+
savePositions: (positions: readonly {
|
|
1517
|
+
documentId: string;
|
|
1518
|
+
x: number;
|
|
1519
|
+
y: number;
|
|
1520
|
+
}[], existingIds: readonly string[]) => void;
|
|
1521
|
+
/** Modifie une seule entrée : taille, étiquette… sans toucher au reste. */
|
|
1522
|
+
patchNode: (documentId: string, patch: Partial<Omit<NodeLayout, 'documentId'>>) => void;
|
|
1523
|
+
/** Modifie une seule valeur de gestion interne. */
|
|
1524
|
+
patchField: (documentId: string, fieldId: string, value: string) => void;
|
|
1525
|
+
/** Enregistre les positions des sections de la carte des composants. */
|
|
1526
|
+
saveSections: (positions: readonly SectionLayout[]) => void;
|
|
1527
|
+
/** Efface la disposition manuelle : le placement automatique reprend la main. */
|
|
1528
|
+
reset: () => void;
|
|
1529
|
+
/** Idem, pour la seule carte des composants. */
|
|
1530
|
+
resetSections: () => void;
|
|
1531
|
+
}
|
|
1532
|
+
/**
|
|
1533
|
+
* Une seule instance de la disposition par outil.
|
|
1534
|
+
*
|
|
1535
|
+
* Le document `ncfBoardLayout` est réécrit en entier à chaque enregistrement :
|
|
1536
|
+
* deux instances du hook, chacune avec son état, finiraient par s'écraser —
|
|
1537
|
+
* régler le board effacerait les colonnes, et réciproquement.
|
|
1538
|
+
*/
|
|
1539
|
+
export declare function BoardLayoutProvider(props: {
|
|
1540
|
+
children: ReactNode;
|
|
1541
|
+
}): import("react").JSX.Element;
|
|
1542
|
+
export declare function useBoardLayout(): BoardLayoutState;
|
|
1543
|
+
/**
|
|
1544
|
+
* Plafond du balayage. La requête rapatrie les documents entiers : c'est le
|
|
1545
|
+
* seul moyen générique de compter les blocs imbriqués et de relever les liens
|
|
1546
|
+
* internes, mais ça se borne. 1000 documents couvrent la cible des 500 pages.
|
|
1547
|
+
*/
|
|
1548
|
+
export declare const CONTENT_SCAN_LIMIT = 1000;
|
|
1549
|
+
interface PageContent {
|
|
1550
|
+
_id: string;
|
|
1551
|
+
_type: string;
|
|
1552
|
+
_updatedAt?: string;
|
|
1553
|
+
[key: string]: unknown;
|
|
1554
|
+
}
|
|
1555
|
+
interface PageContentsState {
|
|
1556
|
+
/** Contenu par identifiant de page publiée, brouillon prioritaire. */
|
|
1557
|
+
contents: Map<string, PageContent>;
|
|
1558
|
+
/** Vrai quand le plafond est atteint : les chiffres sont alors partiels. */
|
|
1559
|
+
truncated: boolean;
|
|
1560
|
+
scanned: number;
|
|
1561
|
+
loading: boolean;
|
|
1562
|
+
error: Error | null;
|
|
1563
|
+
refresh: () => void;
|
|
1564
|
+
}
|
|
1565
|
+
/**
|
|
1566
|
+
* Contenu des pages, partagé par l'outil Composants et par le board. Une
|
|
1567
|
+
* page « modifiée » existe en double (publiée + brouillon) : la fusion garde
|
|
1568
|
+
* la version de référence, sinon ses blocs et ses liens compteraient deux fois.
|
|
1569
|
+
*/
|
|
1570
|
+
export declare function usePageContents(): PageContentsState;
|
|
1571
|
+
interface PagesState {
|
|
1572
|
+
rows: PageRow[];
|
|
1573
|
+
loading: boolean;
|
|
1574
|
+
error: Error | null;
|
|
1575
|
+
refresh: () => void;
|
|
1576
|
+
}
|
|
1577
|
+
/**
|
|
1578
|
+
* Toutes les pages du site, brouillons compris, tenues à jour.
|
|
1579
|
+
*
|
|
1580
|
+
* Seules les colonnes de données affichées sont projetées : sur 500 pages, en
|
|
1581
|
+
* remonter tout le document coûterait cher pour des valeurs que personne ne
|
|
1582
|
+
* regarde.
|
|
1583
|
+
*/
|
|
1584
|
+
export declare function usePages(documentColumns?: readonly ResolvedDocumentColumn[]): PagesState;
|
|
1585
|
+
/** De quoi rendre une occurrence cliquable sans seconde requête. */
|
|
1586
|
+
interface OccurrencePage {
|
|
1587
|
+
id: string;
|
|
1588
|
+
type: string;
|
|
1589
|
+
title: string;
|
|
1590
|
+
}
|
|
1591
|
+
interface OccurrencesState {
|
|
1592
|
+
blockTypes: BlockTypeInfo[];
|
|
1593
|
+
occurrences: BlockOccurrence[];
|
|
1594
|
+
/** Pages indexées par identifiant, pour résoudre `documentIds`. */
|
|
1595
|
+
pagesById: Map<string, OccurrencePage>;
|
|
1596
|
+
truncated: boolean;
|
|
1597
|
+
scanned: number;
|
|
1598
|
+
loading: boolean;
|
|
1599
|
+
error: Error | null;
|
|
1600
|
+
refresh: () => void;
|
|
1601
|
+
}
|
|
1602
|
+
export declare function useOccurrences(): OccurrencesState;
|
|
1603
|
+
/** Figée : une montée de version d'API doit être un choix, pas un effet de bord. */
|
|
1604
|
+
export declare const KIT_API_VERSION = "2026-09-01";
|
|
1605
|
+
/**
|
|
1606
|
+
* Client du kit. `perspective: 'raw'` est indispensable : la perspective par
|
|
1607
|
+
* défaut masque les brouillons, et sans eux une page « modifiée » ou « jamais
|
|
1608
|
+
* publiée » serait invisible dans la liste.
|
|
1609
|
+
*/
|
|
1610
|
+
export declare function useKitClient(): SanityClient;
|
|
1611
|
+
/** camelCase / PascalCase / dotted -> kebab-case. */
|
|
1612
|
+
export declare function toKebabCase(value: string): string;
|
|
1613
|
+
/**
|
|
1614
|
+
* Nom court d'un bloc : le type amputé de son préfixe de convention.
|
|
1615
|
+
* `blockName('section.imageText', 'section.')` -> 'imageText'
|
|
1616
|
+
*/
|
|
1617
|
+
export declare function blockName(type: string, namespace: string): string;
|
|
1618
|
+
/**
|
|
1619
|
+
* Remplit un gabarit d'URL. `{name}` garde la casse d'origine (les captures
|
|
1620
|
+
* générées par la CI sont nommées ainsi : imageText.png), `{kebab}` la
|
|
1621
|
+
* transforme pour les cibles qui l'exigent.
|
|
1622
|
+
*/
|
|
1623
|
+
export declare function fillTemplate(template: string, type: string, namespace: string): string;
|
|
1624
|
+
/** Libellé lisible par défaut : 'imageText' -> 'Image text'. */
|
|
1625
|
+
export declare function humanizeBlockName(type: string, namespace: string): string;
|
|
1626
|
+
/** Noms des outils dans la barre du Studio. Exportés pour filtrer `tools`. */
|
|
1627
|
+
export declare const NCF_PAGES_TOOL = "ncf-pages";
|
|
1628
|
+
export declare const NCF_COMPONENTS_TOOL = "ncf-components";
|
|
1629
|
+
export declare const NCF_HISTORY_TOOL = "ncf-history";
|
|
1630
|
+
export declare const NCF_TOOL_NAMES: readonly ["ncf-pages", "ncf-components", "ncf-history"];
|
|
1631
|
+
/**
|
|
1632
|
+
* Plugin Studio de NoCode Factory : Pages, Composants, Historique.
|
|
1633
|
+
*
|
|
1634
|
+
* ```ts
|
|
1635
|
+
* plugins: [ncfKit({pageTypes: [{type: 'homePage', path: '/'}, 'page']})]
|
|
1636
|
+
* ```
|
|
1637
|
+
*
|
|
1638
|
+
* La configuration est validée au démarrage. Une option invalide n'empêche
|
|
1639
|
+
* pas le Studio de démarrer : l'onglet concerné affiche le détail à corriger.
|
|
1640
|
+
*/
|
|
1641
|
+
export declare const ncfKit: import("sanity").Plugin<NcfKitConfig>;
|
|
1642
|
+
export { type AddColumnInput, type Annotation, type AnnotationsState, type BlockOccurrence, type BlockTypeInfo, type BoardEdge, type BoardGraph, type BoardLayoutState, type BoardNode, CONTENT_SCAN_LIMIT as OCCURRENCE_SCAN_LIMIT, type Change, type ChangeKind, type CollectedLinks, type ColorBy, type ColorOptions, type ConfigIssue, type DeriveOptions, type GroupBy, type GroupOptions, type HistoryDetail, type HistoryEvent, type IssueLevel, type KitContextValue, type LayoutMode, type MergedDoc, type NcfBoardTag, type NcfComponentPreviewConfig, type NcfDocumentColumn, type NcfEnvironment, type NcfHistoryConfig, type NcfI18nConfig, type NcfInternalField, type NcfInternalFieldOption, type NcfKitConfig, type NcfPageTypeConfig, type NcfPageTypeInput, type NcfToolName, type NcfToolsConfig, type NodeLayout, type NodePosition, type OccurrenceInput, type OccurrencePage, type OccurrencesState, type PageContent, type PageContentsState, type PageDoc, type PageFilters, type PageRow, type PageStatus, type PagesState, type PathInput, type Positioned, type PresentationOptions, type PreviewPerspective, type PreviewTargetState, type ProjectStatus, type Registration, type ResolvedComponentPreview, type ResolvedDocumentColumn, type ResolvedHistory, type ResolvedI18n, type ResolvedKitConfig, type ResolvedPageType, type RowColor, type RowGroup, type SchemaFieldLike, type SchemaTypeLike, type SectionLayout, type SectionMapNode, type SectionOrder, type SectionsMapOptions, type Segment, type SiteRoutesRegistry, type SortDirection, type SortKey, type ThumbnailInput, type VersionedDoc };
|
|
1643
|
+
//# sourceMappingURL=index.d.ts.map
|