@unitninety/site-kit 1.6.2 → 1.6.4

package/src/site/assemble.ts

@@ -48,7 +48,7 @@ const declOf = (site: Site, d: ReplyDocument): DocumentDecl | null => {
 export function assemble(site: Site, reply: Reply, opts: AssembleOptions): RouteRead {
   if (reply.status === 'missing') {
     if (opts.stale && opts.defaults && declaredCodePage(site, opts.target))
-      return { ...assemble(site, replyFrom(site, opts.defaults, opts.target, reply.manifest), { ...opts, stale: false, defaults: null }), unavailable: true }
+      return { ...assemble(site, replyFrom(site, opts.defaults, opts.target, reply.manifest, opts.draft), { ...opts, stale: false, defaults: null }), unavailable: true }
     return { status: 'missing', tags: reply.tags }
   }
   const d = reply.document

package/src/site/defineSite.ts

@@ -94,8 +94,8 @@ export function defineSite(input: { singles: Singles; collections: Record<string
   for (const [k, c] of Object.entries(input.collections)) if (c.route) claim(c.route, `collection ${k}`)
   for (const [k, t] of Object.entries(input.pageTypes)) claim(t.route, `page type ${k}`)
   const schema: Schema = {
-    blocks: Object.fromEntries([...blocks.values()].map((b) => [b.name, { name: b.name, label: b.label, fields: strip(b.fields), ...(b.entry ? { entry: b.entry.name } : {}), order: Object.keys(b.fields) } satisfies BlockDecl])),
-    collections: Object.fromEntries(Object.values(input.collections).map((c) => [c.name, { name: c.name, label: c.label, fields: strip(c.fields), ...(c.template ? { template: JSON.parse(JSON.stringify(c.template.zone)) } : {}), ...(c.defaultSort ? { defaultSort: c.defaultSort } : {}), order: Object.keys(c.fields) } satisfies CollectionDecl])),
+    blocks: Object.fromEntries([...blocks.values()].map((b) => [b.name, { name: b.name, label: b.label, fields: strip(b.fields), ...(b.shared ? { shared: b.shared } : {}), ...(b.entry ? { entry: b.entry.name } : {}), order: Object.keys(b.fields) } satisfies BlockDecl])),
+    collections: Object.fromEntries(Object.values(input.collections).map((c) => [c.name, { name: c.name, label: c.label, fields: strip(c.fields), ...(c.authoring ? { authoring: JSON.parse(JSON.stringify(c.authoring)) } : {}), ...(c.template ? { template: JSON.parse(JSON.stringify(c.template.zone)) } : {}), ...(c.defaultSort ? { defaultSort: c.defaultSort } : {}), order: Object.keys(c.fields) } satisfies CollectionDecl])),
     singles: Object.fromEntries(Object.values(input.singles).map((s) => [s.key, { key: s.key, field: JSON.parse(JSON.stringify(s.decl)) }])),
   }
   // Finding 1: seed entries were checked only when seeded, at the platform or in the defaults store.

package/src/site/documents.ts

@@ -6,12 +6,12 @@ export const humanise = (name: string) => name.replace(/([a-z])([A-Z])/g, '$1 $2
 
 export const defineSingles = <M extends Record<string, Decl<unknown>>>(map: M): { [K in keyof M]: SingleDef<M[K] extends Decl<infer R> ? R : never> } =>
   Object.fromEntries(Object.entries(map).map(([key, decl]) => [key, { key, decl }])) as never
-export const collection = <F extends Fields>(name: string, o: { label?: string; fields: F; route?: string; defaultSort?: CollectionDef['defaultSort']; entries?: EntrySeed[] }): CollectionDef<F> =>
-  ({ kind: 'collection', name, label: o.label ?? humanise(name), fields: o.fields, route: o.route, defaultSort: o.defaultSort, ...(o.entries ? { entries: o.entries } : {}) })
+export const collection = <F extends Fields>(name: string, o: { label?: string; fields: F; route?: string; defaultSort?: CollectionDef['defaultSort']; entries?: EntrySeed[]; authoring?: CollectionDef['authoring'] }): CollectionDef<F> =>
+  ({ kind: 'collection', name, label: o.label ?? humanise(name), fields: o.fields, route: o.route, defaultSort: o.defaultSort, ...(o.authoring ? { authoring: o.authoring } : {}), ...(o.entries ? { entries: o.entries } : {}) })
 export const withTemplate = <C extends CollectionDef>(c: C, zone: Decl<unknown>, o: { layout?: string } = {}): C =>
   ({ ...c, template: { zone: zone as ZoneDecl, layout: o.layout } })
-export const block = <F extends Fields, C extends CollectionDef | undefined = undefined>(name: string, o: { label?: string; fields: F; component: unknown; entry?: C }): BlockDef<F, C> =>
-  ({ kind: 'block', name, label: o.label ?? humanise(name), fields: o.fields, component: o.component, entry: o.entry })
+export const block = <F extends Fields, C extends CollectionDef | undefined = undefined>(name: string, o: { label?: string; fields: F; component: unknown; entry?: C; shared?: BlockDef['shared'] }): BlockDef<F, C> =>
+  ({ kind: 'block', name, label: o.label ?? humanise(name), fields: o.fields, component: o.component, entry: o.entry, ...(o.shared ? { shared: o.shared } : {}) })
 export const layout = (o: { default?: boolean; parent?: string }, entries: Array<BlockDef | typeof SLOT>): LayoutDef => ({ kind: 'layout', ...o, entries })
 export const page = (o: { route: string; layout?: string; blocks: Decl<unknown> }): PageDef => ({ kind: 'page', route: o.route, layout: o.layout, blocks: o.blocks as ZoneDecl })
 export const pageType = (o: { label: string; route: string; layout?: string; blocks: Decl<unknown> }): PageTypeDef => ({ kind: 'pageType', ...o, blocks: o.blocks as ZoneDecl })

package/src/site/fields.ts

@@ -19,20 +19,20 @@ export const image = (o: Common & { default?: unknown; constraints?: unknown; va
   leaf<ImageRead>('u90/image', o, { constraints: o.constraints, variants: o.variants })
 export const video = (o: Common & { default?: unknown; poster?: unknown } = {}) => leaf<VideoRead>('u90/video', o, { poster: o.poster })
 export const file = (o: Common & { default?: unknown; mimeTypes?: string[]; maxBytes?: number } = {}) => leaf<FileRead>('u90/file', o, { mimeTypes: o.mimeTypes, maxBytes: o.maxBytes })
-export const link = (o: Common & { default?: unknown; allow?: Array<'page' | 'entry' | 'url' | 'email' | 'tel'> } = {}) => leaf<LinkRead>('u90/link', o, { allow: o.allow })
+export const link = (o: Common & { default?: unknown; allow?: Array<'page' | 'entry' | 'file' | 'url' | 'email' | 'tel'> } = {}) => leaf<LinkRead>('u90/link', o, { allow: o.allow })
 export const date = (o: Common & { default?: string; min?: string; max?: string } = {}) => leaf<DateRead>('u90/date', o, { min: o.min, max: o.max })
 export const number = (o: Common & { default?: number; integer?: boolean; min?: number; max?: number; step?: number } = {}) => leaf<NumberRead>('u90/number', o, { integer: o.integer, min: o.min, max: o.max, step: o.step })
 export const boolean = (o: Common & { default?: boolean } = {}) => leaf<BooleanRead>('u90/boolean', o, {})
 export const choice = (values: Array<string | { value: string; label: string }>, o: Common & { default?: string | string[]; multiple?: boolean } = {}) =>
   leaf<ChoiceReadValue>('u90/choice', o, { values: values.map((v) => (typeof v === 'string' ? { value: v, label: v[0].toUpperCase() + v.slice(1) } : v)), multiple: o.multiple })
-export const relation = (to: string, o: Common & { default?: unknown; many?: boolean; unique?: boolean; inverseOf?: string; depth?: number } = {}) =>
+export const relation = (to: string, o: Common & { default?: unknown; many?: boolean; unique?: boolean; inverseOf?: string; depth?: number; previewFields?: string[] } = {}) =>
   leaf<EntryRead | EntryRead[] | null>('u90/relation', o, {
-    to, inverseOf: o.inverseOf, depth: o.depth,
+    to, inverseOf: o.inverseOf, depth: o.depth, previewFields: o.previewFields,
     cardinality: o.inverseOf ? (o.many ? 'many-to-many' : o.unique ? 'one-to-one' : 'one-to-many') : o.many ? 'many-to-many' : o.unique ? 'one-to-one' : 'many-to-one',
   })
-export const selection = (to: string, o: Common & { default?: unknown; many?: boolean; max?: number; depth?: number } = {}) =>
-  leaf<EntriesRead>('u90/selection', o, { to, many: o.many, max: o.max, depth: o.depth })
-export const query = (to: string, o: Common & { default?: unknown } = {}) => leaf<EntriesRead>('u90/query', o, { to })
+export const selection = (to: string, o: Common & { default?: unknown; many?: boolean; max?: number; depth?: number; previewFields?: string[] } = {}) =>
+  leaf<EntriesRead>('u90/selection', o, { to, many: o.many, max: o.max, depth: o.depth, previewFields: o.previewFields })
+export const query = (to: string, o: Common & { default?: unknown; previewFields?: string[] } = {}) => leaf<EntriesRead>('u90/query', o, { to, previewFields: o.previewFields })
 export const single = <R>(s: SingleDef<R>, o: Common = {}): Decl<R> => leaf<R>('u90/single', o, { key: s.key })
 
 export const group = <F extends Fields>(fields: F, o: { label?: string } = {}): Decl<{ [K in keyof F]: Read<F[K]> }> & { readonly __group: true } =>

package/src/site/formView.ts

@@ -0,0 +1,175 @@
+import { z } from 'zod'
+import { isLeaf, type CollectionDecl, type FieldDecl } from '../elements/define'
+import { orderedEntries } from '../elements/order'
+
+const safeKey = z
+  .string()
+  .min(1)
+  .max(200)
+  .refine((key) => !['__proto__', 'constructor', 'prototype'].includes(key), 'Invalid field key.')
+const Field = z.strictObject({ key: safeKey, width: z.enum(['half', 'full']) })
+const Group = z.strictObject({
+  id: z.string().regex(/^[a-zA-Z0-9_-]{1,80}$/),
+  label: z.string().trim().max(80),
+  fields: z.array(Field).max(500),
+})
+/** UI presentation only. No visibility, defaults, validation or site design settings. */
+export const CollectionViewSchema = z.strictObject({
+  version: z.literal(1),
+  groups: z.array(Group).min(1).max(50),
+})
+export const CollectionViewsSchema = z
+  .custom<Record<string, unknown>>(
+    (value) =>
+      !!value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      Object.keys(value).length <= 200 &&
+      Object.keys(value).every((key) => !['__proto__', 'constructor', 'prototype'].includes(key)),
+    'Invalid collection views.',
+  )
+  .pipe(z.record(safeKey, CollectionViewSchema))
+export type CollectionView = z.infer<typeof CollectionViewSchema>
+export type CollectionViews = z.infer<typeof CollectionViewsSchema>
+export type CollectionViewField = {
+  key: string
+  label: string
+  width: 'half' | 'full'
+  required: boolean
+}
+const humanise = (name: string) =>
+  name
+    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+    .replace(/[-_]/g, ' ')
+    .replace(/^./, (c) => c.toUpperCase())
+const editable = (field: FieldDecl): boolean =>
+  isLeaf(field)
+    ? !field.lock?.includes('$')
+    : field.container !== 'u90/group' || Object.values(field.fields).some(editable)
+
+/** Complex schema containers remain single units, with their own nested editors. */
+export function collectionViewFields(decl: CollectionDecl): CollectionViewField[] {
+  const fields = orderedEntries(decl.fields, decl.order).filter(([, field]) => editable(field))
+  const title = fields.find(([, field]) => isLeaf(field) && field.element === 'u90/text')?.[0]
+  return fields.map(([key, field]) => ({
+    key,
+    label: field.label || humanise(key),
+    required:
+      key === title ||
+      (isLeaf(field)
+        ? field.required === true
+        : field.container === 'u90/list' && (field.min ?? 0) > 0),
+    width:
+      key === title ||
+      !isLeaf(field) ||
+      field.options?.multiline === true ||
+      ['u90/image', 'u90/video', 'u90/file', 'u90/rich-text', 'u90/link', 'u90/query'].includes(
+        field.element,
+      )
+        ? 'full'
+        : 'half',
+  }))
+}
+const MAX_GROUPS = 50
+const MAX_FIELDS_PER_GROUP = 500
+export const defaultCollectionView = (fields: CollectionViewField[]): CollectionView => {
+  if (fields.length > MAX_GROUPS * MAX_FIELDS_PER_GROUP)
+    throw new Error('This collection has too many fields to configure.')
+  return {
+    version: 1,
+    groups: Array.from(
+      { length: Math.max(1, Math.ceil(fields.length / MAX_FIELDS_PER_GROUP)) },
+      (_, i) => ({
+        id: i ? `fields_${i}` : 'fields',
+        label: '',
+        fields: fields
+          .slice(i * MAX_FIELDS_PER_GROUP, (i + 1) * MAX_FIELDS_PER_GROUP)
+          .map(({ key, width }) => ({ key, width })),
+      }),
+    ),
+  }
+}
+
+/** Saved views from older schemas may not conceal newly added fields or revive locked ones. */
+export function reconcileCollectionView(
+  input: unknown,
+  fields: CollectionViewField[],
+): CollectionView {
+  const parsed = CollectionViewSchema.safeParse(input)
+  if (!parsed.success) return defaultCollectionView(fields)
+  const available = new Set(fields.map((f) => f.key))
+  const seen = new Set<string>()
+  const ids = new Set<string>()
+  const groups = parsed.data.groups
+    .filter((group) => {
+      if (ids.has(group.id)) return false
+      ids.add(group.id)
+      return true
+    })
+    .map((group) => ({
+      ...group,
+      fields: group.fields.filter((field) => {
+        if (!available.has(field.key) || seen.has(field.key)) return false
+        seen.add(field.key)
+        return true
+      }),
+    }))
+  const missing = fields
+    .filter((field) => !seen.has(field.key))
+    .map(({ key, width }) => ({ key, width }))
+  for (const field of missing) {
+    let target = groups.find((group) => !group.label && group.fields.length < MAX_FIELDS_PER_GROUP)
+    if (!target && groups.length < MAX_GROUPS) {
+      let id = 'fields'
+      let suffix = 1
+      while (ids.has(id)) id = `fields_${suffix++}`
+      ids.add(id)
+      target = { id, label: '', fields: [] }
+      groups.push(target)
+    }
+    target ??= groups.find((group) => group.fields.length < MAX_FIELDS_PER_GROUP)
+    if (!target) throw new Error('This collection has too many fields to configure.')
+    target.fields.push(field)
+  }
+  return { version: 1, groups }
+}
+
+/** Writes must account for every field, exactly once. Reads alone reconcile schema drift. */
+export function validateCollectionView(
+  input: unknown,
+  fields: CollectionViewField[],
+): CollectionView {
+  const view = CollectionViewSchema.parse(input)
+  if (new Set(view.groups.map((g) => g.id)).size !== view.groups.length)
+    throw new Error('Each group needs a unique ID.')
+  const keys = view.groups.flatMap((g) => g.fields.map((f) => f.key))
+  const expected = new Set(fields.map((f) => f.key))
+  if (
+    keys.length !== expected.size ||
+    new Set(keys).size !== keys.length ||
+    keys.some((key) => !expected.has(key))
+  )
+    throw new Error('Include every editable field once. Reload the view if the schema changed.')
+  return view
+}
+
+export function collectionViewsIssues(
+  input: CollectionViews | undefined,
+  collections: Record<string, CollectionDecl>,
+): { path: string; message: string }[] {
+  return Object.entries(input ?? {}).flatMap(([name, view]) => {
+    if (!Object.hasOwn(collections, name))
+      return [{ path: `collectionViews/${name}`, message: 'This collection is not declared.' }]
+    try {
+      validateCollectionView(view, collectionViewFields(collections[name]))
+      return []
+    } catch (error) {
+      return [
+        {
+          path: `collectionViews/${name}`,
+          message: error instanceof Error ? error.message : 'Invalid collection view.',
+        },
+      ]
+    }
+  })
+}

package/src/site/index.ts

@@ -12,3 +12,6 @@ export { metadataFor, type PageSeoInput } from '../seo/metadata'
 export { organisationJsonLd } from '../seo/jsonLd'
 export { robotsFor } from '../seo/robots'
 export { sitemapFor } from '../seo/sitemap'
+
+export { SeoSeedsSchema, DocumentSeoSeedSchema, SiteSeoSeedSchema, seoSeedIssues, seoSeedAssets, type SeoSeeds, type DocumentSeoSeed, type SiteSeoSeed } from '../seo/seeds'
+export { CollectionViewSchema, CollectionViewsSchema, collectionViewFields, defaultCollectionView, reconcileCollectionView, validateCollectionView, collectionViewsIssues, type CollectionView, type CollectionViews, type CollectionViewField } from './formView'

package/src/site/replies.ts

@@ -22,7 +22,7 @@ const tagOf = (r: Ref): string =>
   r.kind === 'media' ? `media:${r.id}` : r.kind === 'page' ? `page:${r.id}` : r.kind === 'single' ? `single:${r.key}` : r.kind === 'entry' ? `entry:${r.id}` : `collection:${r.collection}`
 
 /** A query over the store: `where` (eq, neq, in, not-in, is-set), a field `sort`, then the placement's picks and `limit`, which `applyQueryPicks` applies. */
-function runQuery(store: Store, collection: string, q: QueryStored): { ids: Id[]; total: number } {
+function runQuery(store: Store, collection: string, q: QueryStored, draft: boolean): { ids: Id[]; total: number; matches?: Id[] } {
   let rows = [...store.entries.values()].filter((e) => e.collection === collection)
   for (const w of q.where ?? [])
     rows = rows.filter((e) => {
@@ -31,7 +31,8 @@ function runQuery(store: Store, collection: string, q: QueryStored): { ids: Id[]
     })
   const sort = q.sort
   if (sort && sort !== 'manual') rows.sort((a, b) => String(a.fields[sort.field]).localeCompare(String(b.fields[sort.field])) * (sort.dir === 'desc' ? -1 : 1))
-  return applyQueryPicks(rows.map((r) => r.id), q, (id) => store.entries.has(entryKey(collection, id)))
+  const matches = rows.map(r => r.id)
+  return { ...applyQueryPicks(matches, q, id => store.entries.has(entryKey(collection, id))), ...(draft ? { matches } : {}) }
 }
 
 type Found = { doc: ReplyDocument; decl: DocumentDecl }
@@ -59,7 +60,7 @@ const entryFound = (site: Site, store: Store, collection: string, slug: string):
  * lookups they ask for, and the tags the read depends on. The fake answers with it, and a site
  * reading its own defaults goes through it too, so every read is assembled the same way.
  */
-export function replyFrom(site: Site, store: Store, target: ReplyTarget, manifest: string): Reply {
+export function replyFrom(site: Site, store: Store, target: ReplyTarget, manifest: string, draft = false): Reply {
   let found: Found | null = null
   if ('route' in target) {
     const p = [...store.pages.values()].find((x) => x.route === target.route)
@@ -96,7 +97,7 @@ export function replyFrom(site: Site, store: Store, target: ReplyTarget, manifes
   const queries: DocumentReply['queries'] = {}
   const inverses: DocumentReply['inverses'] = {}
   for (const r of lookups) {
-    if (r.kind === 'query') queries[queryKey(r.collection, r.query)] ??= runQuery(store, r.collection, r.query as QueryStored)
+    if (r.kind === 'query') queries[queryKey(r.collection, r.query)] ??= runQuery(store, r.collection, r.query as QueryStored, draft)
     if (r.kind === 'inverse')
       inverses[inverseKey(r.collection, r.field, r.id)] ??= [...store.entries.values()]
         .filter((e) => e.collection === r.collection && (Array.isArray(e.fields[r.field]) ? (e.fields[r.field] as unknown[]) : [e.fields[r.field]]).some((v) => String(v) === String(r.id)))

package/src/site/types.ts

@@ -31,11 +31,12 @@ export type EntrySeed = { slug: string; fields?: Record<string, unknown>; blocks
 export type CollectionDef<F extends Fields = Fields> = {
   kind: 'collection'; name: string; label: string; fields: F
   route?: string; defaultSort?: CollectionDecl['defaultSort']
+  authoring?: CollectionDecl['authoring']
   template?: { zone: ZoneDecl; layout?: string }
   entries?: EntrySeed[]
 }
 export type BlockDef<F extends Fields = Fields, C extends CollectionDef | undefined = CollectionDef | undefined> = {
-  kind: 'block'; name: string; label: string; fields: F; component: unknown; entry?: C
+  kind: 'block'; name: string; label: string; fields: F; component: unknown; entry?: C; shared?: BlockDecl['shared']
 }
 export type LayoutDef = { kind: 'layout'; default?: boolean; parent?: string; entries: Array<BlockDef | 'SLOT'> }
 export type PageDef = { kind: 'page'; route: string; layout?: string; blocks: ZoneDecl }
@@ -73,3 +74,4 @@ export type BlockProps<B> = B extends BlockDef<infer F, infer C>
   ? Simplify<{ [K in keyof F]: Read<F[K]> } & (C extends CollectionDef ? { entry: EntryReadOf<C> } : {})>
   : never
 export type { FieldDecl, LeafDecl, GroupDecl, ListDecl, ZoneDecl, BlockDecl, CollectionDecl, SingleDecl, Schema }
+export type { CollectionAuthoring, CollectionAuthoringAnchor, CollectionAuthoringSections } from '../elements'

package/src/site/version.ts

@@ -1 +1 @@
-export const SITE_KIT_VERSION = '1.6.2'
+export const SITE_KIT_VERSION = '1.6.4'

package/src/site/wire.ts

@@ -33,7 +33,7 @@ export type DocumentReply = {
   /** By `entryKey(collection, id)`. */
   entries: Record<string, EntryRecord>
   /** By `queryKey(collection, query)`. */
-  queries: Record<string, { ids: Id[]; total: number }>
+  queries: Record<string, { ids: Id[]; total: number; matches?: Id[] }>
   /** By `inverseKey(collection, field, id)`. */
   inverses: Record<string, Id[]>
   tags: string[]

package/src/testing/fake.ts

@@ -6,7 +6,7 @@ import { seedCtx, seedEntry, seedSite, type Store } from '../site/store'
 
 export type { RouteRead }
 const assembled = (site: Site, store: Store, target: ReplyTarget, draft: boolean): RouteRead =>
-  assemble(site, replyFrom(site, store, target, ''), { draft, target, stale: false, defaults: null })
+  assemble(site, replyFrom(site, store, target, '', draft), { draft, target, stale: false, defaults: null })
 /** A route read against a store, assembled as the site assembles a platform's reply. */
 export const routeRead = (site: Site, store: Store, pathname: string, draft: boolean): RouteRead => assembled(site, store, { route: pathname }, draft)
 /**
@@ -83,14 +83,14 @@ export async function createFakePlatform(site: Site, store?: Store, opts: { mani
     // A site with languages hears which language answered, as the platform says it, and which languages have copy of the document (ruling R2).
     const answer = (reply: Reply) =>
       json(reply.status === 'ok' && chain?.locale ? { ...reply, locale: chain.locale, ...(languages ? { translated: translatedOf(`${reply.document.kind}:${reply.document.id}`) } : {}) } : reply)
-    if (p === '/route') return answer(replyFrom(site, view, { route: url.searchParams.get('path') ?? '/' }, manifest))
-    if (p.startsWith('/page/')) return answer(replyFrom(site, view, { page: decodeURIComponent(p.slice(6)) }, manifest))
+    if (p === '/route') return answer(replyFrom(site, view, { route: url.searchParams.get('path') ?? '/' }, manifest, draft))
+    if (p.startsWith('/page/')) return answer(replyFrom(site, view, { page: decodeURIComponent(p.slice(6)) }, manifest, draft))
     if (p.startsWith('/entry/')) {
       // The read client encodes both segments (and a URL's pathname keeps them encoded), so a
       // non-ASCII slug arrives as `caf%C3%A9`; decoded after the split, so an encoded `/` stays in its segment.
       let segments: string[]
       try { segments = p.split('/').slice(2).map(decodeURIComponent) } catch { return json({ error: 'malformed path' }, 400) }
-      return answer(replyFrom(site, view, { entry: { collection: segments[0], slug: segments[1] } }, manifest))
+      return answer(replyFrom(site, view, { entry: { collection: segments[0], slug: segments[1] } }, manifest, draft))
     }
     if (p === '/site') return opts.failSite ? json({ error: 'site settings unavailable' }, 500) : json(languages ? { ...settings, languages } : settings)
     if (p === '/sitemap') {