rimecms 0.33.0 → 1.0.0

package/dist/core/prototype/collection/operations/find-by-ids.d.ts

@@ -0,0 +1,19 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+import type { GenericDoc } from '../../types.js';
+export type FindByIdsArgs = {
+    ids: string[];
+    locale?: string | undefined;
+    depth?: number;
+    /** See the collection's findById. */
+    localeFallback?: boolean;
+};
+type Args = FindByIdsArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+/**
+ * The published documents with these ids, in one read. A missing id, or one this reader is refused,
+ * is left out.
+ */
+export declare const findByIds: <T extends GenericDoc>(args: Args) => Promise<T[]>;
+export {};

package/dist/core/prototype/collection/operations/find-by-ids.js

@@ -0,0 +1,54 @@
+import { readableReferences } from '../../../fields/util.js';
+import { RimeError } from '../../../errors/index.js';
+import { logger } from '../../../logger.server.js';
+import { readDocuments, runBeforeOperation } from '../../../pipeline/run.server.js';
+import { trycatch } from '../../../../util/function.js';
+/**
+ * The published documents with these ids, in one read. A missing id, or one this reader is refused,
+ * is left out.
+ */
+export const findByIds = async (args) => {
+    const { ctx, ids, locale, depth, localeFallback } = args;
+    const { config, event, isSystemOperation } = ctx;
+    // The beforeOperation chain findById runs, once per id: a read rule that looks at `id` answers
+    // for each document as it would one at a time. A refusal leaves the id out; anything else throws.
+    const readable = [];
+    for (const id of ids) {
+        const [error] = await trycatch(() => runBeforeOperation({
+            config,
+            event,
+            operation: 'read',
+            context: { isSystemOperation, params: { id, locale, depth } }
+        }));
+        if (!error)
+            readable.push(id);
+        else if (!(error instanceof RimeError && error.code === RimeError.UNAUTHORIZED))
+            throw error;
+    }
+    if (!readable.length)
+        return [];
+    const documentsRaw = await event.locals.rime.adapter.collection(config.slug).findMany({
+        // `id` names the document on a versioned collection too: the adapter reads it as `ownerId`.
+        query: { where: { id: { in_array: readable } } },
+        locale,
+        localeFallback,
+        resolve: isSystemOperation ? undefined : readableReferences(config.fields, event.locals.user),
+        // The published row, as findById reads with no `latest` and no `versionId`.
+        content: ctx.versionQuery({})
+    });
+    const results = await readDocuments({
+        raws: documentsRaw,
+        config,
+        event,
+        context: { isSystemOperation, params: { locale, depth, select: [] } },
+        locale,
+        localeFallback,
+        depth
+    });
+    return results.flatMap((result) => {
+        if (result.status === 'fulfilled')
+            return [result.value.doc];
+        logger.error(result.reason.message, result.reason);
+        return [];
+    });
+};

package/dist/core/prototype/collection/operations/find.js

@@ -1,5 +1,6 @@
+import { readableReferences } from '../../../fields/util.js';
 import { logger } from '../../../logger.server.js';
-import { readDocument, runBeforeOperation } from '../../../pipeline/run.server.js';
+import { readDocuments, runBeforeOperation } from '../../../pipeline/run.server.js';
 export const find = async (args) => {
     //
     const { ctx, locale, sort, limit, offset, depth, query, latest, select = [], localeFallback } = args;
@@ -32,34 +33,27 @@ export const find = async (args) => {
         locale,
         localeFallback,
         select,
+        resolve: isSystemOperation ? undefined : readableReferences(config.fields, event.locals.user),
         // Which content row each document shows. `and`ed with `query` by the adapter, rather than
         // spliced into it — see the collection's findById for where the answer comes from.
         content: ctx.versionQuery({ latest })
     });
-    async function processDocument(documentRaw) {
-        try {
-            const result = await readDocument({
-                raw: documentRaw,
-                config,
-                event,
-                context,
-                locale,
-                localeFallback,
-                depth,
-                select
-            });
-            context = result.context;
-            return result.doc;
-        }
-        catch (error) {
-            // Skip this document and carry on with the next one. The transform is inside the try
-            // alongside the hooks now: a row rime cannot turn into a document is the same kind of
-            // per-row problem as a beforeRead hook rejecting one, and taking the whole query down
-            // for it made a single bad row look like an empty collection.
-            logger.error(error.message, error);
-            return null;
-        }
-    }
-    const documents = await Promise.all(documentsRaw.map((doc) => processDocument(doc)));
-    return documents.filter((d) => !!d);
+    const results = await readDocuments({
+        raws: documentsRaw,
+        config,
+        event,
+        context,
+        locale,
+        localeFallback,
+        depth,
+        select
+    });
+    // A row rime cannot turn into a document, or that a beforeRead hook rejects, is skipped: one bad
+    // row does not take the whole list down.
+    return results.flatMap((result) => {
+        if (result.status === 'fulfilled')
+            return [result.value.doc];
+        logger.error(result.reason.message, result.reason);
+        return [];
+    });
 };

package/dist/core/prototype/collection/operations/update-slug-by-id.d.ts

@@ -0,0 +1,20 @@
+import type { PathRow } from '../../../adapter.js';
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+export type UpdateSlugByIdArgs = {
+    id: string;
+    slug: string;
+    /** The locale whose address changes; the others keep theirs. */
+    locale?: string | undefined;
+};
+type Args = UpdateSlugByIdArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+/**
+ * A page's slug in one locale: its address changes, and the pages under it follow.
+ *
+ * On the published page only, for whoever may update it. A slug a sibling holds is refused as a
+ * field error on `_slug`.
+ */
+export declare const updateSlugById: (args: Args) => Promise<PathRow>;
+export {};

package/dist/core/prototype/collection/operations/update-slug-by-id.js

@@ -0,0 +1,53 @@
+import { RimeError, RimeFormError } from '../../../errors/index.js';
+import { toSlug } from '../../shared/url/format.server.js';
+import { refreshUrls } from '../../shared/url/refresh.server.js';
+/**
+ * A page's slug in one locale: its address changes, and the pages under it follow.
+ *
+ * On the published page only, for whoever may update it. A slug a sibling holds is refused as a
+ * field error on `_slug`.
+ */
+export const updateSlugById = async (args) => {
+    const { ctx, id } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    const locale = args.locale ?? '';
+    if (!config.$url) {
+        throw new RimeError(RimeError.BAD_REQUEST, `${config.slug} has no $url, so no slug`);
+    }
+    if (!isSystemOperation && !config.access.update(event.locals.user, { event, id })) {
+        throw new RimeError(RimeError.UNAUTHORIZED);
+    }
+    const collection = rime.collection(config.slug).system();
+    const byId = { where: { id: { equals: id } } };
+    // Without `latest`, a read with drafts answers the published version only.
+    const [page] = await collection.find({ query: byId, locale: locale || undefined });
+    if (!page) {
+        const [draft] = await collection.find({
+            query: byId,
+            locale: locale || undefined,
+            latest: true
+        });
+        if (!draft)
+            throw new RimeError(RimeError.NOT_FOUND);
+        throw new RimeError(RimeError.BAD_REQUEST, 'the slug changes on the published page');
+    }
+    const value = toSlug(args.slug);
+    if (!value)
+        throw new RimeFormError({ _slug: RimeFormError.REQUIRED_FIELD });
+    const [current] = await rime.adapter.paths.get({ slug: config.slug, ownerId: id, locale });
+    if (!current)
+        throw new RimeError(RimeError.NOT_FOUND);
+    if (current.slug === value)
+        return current;
+    const parentId = page._parent ?? null;
+    const taken = await rime.adapter.paths.siblingSlugs({ slug: config.slug, locale, parentId });
+    if (taken.includes(value))
+        throw new RimeFormError({ _slug: RimeFormError.UNIQUE_FIELD });
+    const row = await rime.adapter.paths.setSlug({ slug: config.slug, ownerId: id, locale, value });
+    if (!row)
+        throw new RimeError(RimeError.NOT_FOUND);
+    await refreshUrls({ event, config, locale, path: row.path });
+    const [updated] = await rime.adapter.paths.get({ slug: config.slug, ownerId: id, locale });
+    return updated;
+};

package/dist/core/prototype/collection/rest/index.server.js

@@ -6,6 +6,7 @@ import { restGet } from './get.server.js';
 import { restGetById } from './get-by-id.server.js';
 import { restLock, restUnlock } from './lock.server.js';
 import { restUpdateById } from './update-by-id.server.js';
+import { restUpdateSlugById } from './update-slug-by-id.server.js';
 /**
  * The REST surface a collection provides.
  *
@@ -20,5 +21,6 @@ export const rest = {
     '': { GET: restGet, POST: restCreate, DELETE: restDelete },
     '[id]': { GET: restGetById, PATCH: restUpdateById, DELETE: restDeleteById },
     '[id]/duplicate': { POST: restDuplicate },
-    '[id]/lock': { POST: restLock, DELETE: restUnlock }
+    '[id]/lock': { POST: restLock, DELETE: restUnlock },
+    '[id]/slug': { PATCH: restUpdateSlugById }
 };

package/dist/core/prototype/collection/rest/update-slug-by-id.server.d.ts

@@ -0,0 +1,2 @@
+/** `PATCH /api/<collection>/<id>/slug` with `{ slug }`: the page's address in the request's locale. */
+export declare const restUpdateSlugById: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/update-slug-by-id.server.js

@@ -0,0 +1,20 @@
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { error, json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/** `PATCH /api/<collection>/<id>/slug` with `{ slug }`: the page's address in the request's locale. */
+export const restUpdateSlugById = endpoint(async ({ event, collection }) => {
+    if (!event.params.id)
+        throw error(404);
+    const [readError, body] = await trycatch(() => event.request.json());
+    if (readError || typeof body?.slug !== 'string')
+        throw error(400, 'a slug is expected');
+    const [updateError, row] = await trycatch(() => collection.updateSlugById({
+        id: event.params.id,
+        slug: body.slug,
+        locale: event.locals.rime.getLocale()
+    }));
+    if (updateError)
+        return handleError(updateError, { context: ERROR_CONTEXT.API });
+    return json({ slug: row.slug, path: row.path, url: row.url });
+});

package/dist/core/prototype/collection/thumbnail/find-thumbnail.d.ts

@@ -1,9 +1,10 @@
 import type { FieldBuilder } from '../../../fields/builders/field-builder.js';
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import type { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
 import type { Field, FormField } from '../../../../fields/types.js';
 interface ThumbnailFieldResult {
     field: FormFieldBuilder<FormField>;
     path: string;
 }
+/** The first relation marked `isThumbnail()`, at a path a config alone can name. */
 export declare function findThumbnailField(fields?: FieldBuilder<Field>[], basePath?: string): ThumbnailFieldResult | null;
 export {};

package/dist/core/prototype/collection/thumbnail/find-thumbnail.js

@@ -1,34 +1,11 @@
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
-import { GroupFieldBuilder } from '../../../../fields/group/index.js';
+import { walkFields } from '../../../fields/walk.js';
 import { RelationFieldBuilder } from '../../../../fields/relation/index.js';
-import { TabsBuilder } from '../../../../fields/tabs/index.js';
+/** The first relation marked `isThumbnail()`, at a path a config alone can name. */
 export function findThumbnailField(fields = [], basePath = '') {
-    for (const field of fields) {
-        // Direct check for isThumbnail
-        if (field instanceof RelationFieldBuilder &&
-            'isThumbnail' in field.get &&
-            field.get.isThumbnail === true) {
-            const path = basePath ? `${basePath}.${field.name}` : field.name;
+    for (const { field, path } of walkFields(fields, { path: basePath, determinate: true })) {
+        if (field instanceof RelationFieldBuilder && field.get.isThumbnail === true) {
             return { field, path };
         }
-        // Check in group
-        if (field instanceof GroupFieldBuilder && field.get.fields) {
-            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
-            const found = findThumbnailField(field.get.fields, groupPath);
-            if (found)
-                return found;
-        }
-        // Check in tabs
-        if (field instanceof TabsBuilder && field.get.tabs) {
-            for (const tab of field.get.tabs) {
-                if (tab.get.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
-                    const found = findThumbnailField(tab.get.fields, tabPath);
-                    if (found)
-                        return found;
-                }
-            }
-        }
     }
     return null;
 }

package/dist/core/prototype/collection/upload/directories/derive.js

@@ -1,3 +1,4 @@
+import { blank } from '../../../blank.js';
 import { prototypeKebab } from '../../../naming.js';
 import { date } from '../../../../../fields/date/index.js';
 import { text } from '../../../../../fields/text/index.js';
@@ -14,6 +15,7 @@ export function makeUploadDirectoriesCollectionClient(collection) {
     const directoriesCollection = {
         slug: slug,
         kebab: prototypeKebab(slug),
+        blank,
         versions: undefined,
         access: {
             read: directoriesConfig?.access?.read || collection.access.read,
@@ -40,7 +42,7 @@ export function makeUploadDirectoriesCollectionClient(collection) {
             text('parent').hidden(),
             ...(directoriesConfig?.fields || []),
             date('createdAt').hidden(),
-            date('updatedAt').hidden()
+            date('updatedAt').hidden().$index()
         ],
         type: 'collection',
         label: {

package/dist/core/prototype/collection/upload/disk/delete.server.js

@@ -1,5 +1,4 @@
 import { logger } from '../../../../logger.server.js';
-import { isFormField } from '../../../../fields/util.js';
 import { existsSync, unlink, unlinkSync } from 'fs';
 import path from 'path';
 /**
@@ -17,7 +16,7 @@ import path from 'path';
  * and with no feature importing another feature to do it.
  */
 const ownsField = (rime, config, name) => {
-    const field = config.fields.filter(isFormField).find((one) => one.name === name);
+    const field = config.fields.find((one) => one.name === name);
     if (!field)
         return false;
     return config._versions ? !!field.get.root : true;

package/dist/core/prototype/define.js

@@ -1,5 +1,6 @@
 import { isStaff } from '../auth/access.js';
 import { FileText } from '@lucide/svelte';
+import { blank } from './blank.js';
 import { prototypeKebab } from './naming.js';
 export const definePrototype = (options = {}) => {
     const name = options.name ?? '';
@@ -23,6 +24,7 @@ export const definePrototype = (options = {}) => {
             ...augmented,
             type: name,
             slug,
+            blank,
             kebab: prototypeKebab(slug),
             fields: augmented.fields || [],
             icon: augmented.icon || FileText,

package/dist/core/prototype/shared/metas/fields.js

@@ -23,5 +23,6 @@ export const metasFields = {
     createdBy: () => text('createdBy').hidden().$root().access(staffOnly),
     createdAt: () => date('createdAt').hidden(),
     updatedBy: () => text('updatedBy').hidden().access(staffOnly),
-    updatedAt: () => date('updatedAt').hidden()
+    // The default sort of every list
+    updatedAt: () => date('updatedAt').hidden().$index()
 };

package/dist/core/prototype/shared/title/find-title.d.ts

@@ -1,5 +1,5 @@
 import type { FieldBuilder } from '../../../fields/builders/field-builder.js';
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import type { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
 import type { DateField } from '../../../../fields/date/index.js';
 import type { EmailField } from '../../../../fields/email/index.js';
 import type { SlugField } from '../../../../fields/slug/index.js';
@@ -10,5 +10,6 @@ interface TitleFieldResult {
     field: FormFieldBuilder<FormField>;
     path: string;
 }
+/** The first field marked `isTitle()`, at a path a config alone can name. */
 export declare function findTitleField(fields?: FieldBuilder<Field>[], basePath?: string): TitleFieldResult | null;
 export {};

package/dist/core/prototype/shared/title/find-title.js

@@ -1,35 +1,12 @@
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
-import { GroupFieldBuilder } from '../../../../fields/group/index.js';
-import { TabsBuilder } from '../../../../fields/tabs/index.js';
+import { isFormField } from '../../../fields/util.js';
+import { walkFields } from '../../../fields/walk.js';
 export const hasMaybeTitle = (field) => ['text', 'date', 'slug', 'email', 'richText'].includes(field.type);
+/** The first field marked `isTitle()`, at a path a config alone can name. */
 export function findTitleField(fields = [], basePath = '') {
-    for (const field of fields) {
-        // Direct check for isTitle
-        if (field instanceof FormFieldBuilder &&
-            hasMaybeTitle(field.get) &&
-            'isTitle' in field.get &&
-            field.get.isTitle === true) {
-            const path = basePath ? `${basePath}.${field.name}` : field.name;
+    for (const { field, path } of walkFields(fields, { path: basePath, determinate: true })) {
+        if (isFormField(field) && hasMaybeTitle(field.get) && field.get.isTitle === true) {
             return { field, path };
         }
-        // Check in group
-        if (field instanceof GroupFieldBuilder && field.get.fields) {
-            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
-            const found = findTitleField(field.get.fields, groupPath);
-            if (found)
-                return found;
-        }
-        // Check in tabs
-        if (field instanceof TabsBuilder && field.get.tabs) {
-            for (const tab of field.get.tabs) {
-                if (tab.get.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
-                    const found = findTitleField(tab.get.fields, tabPath);
-                    if (found)
-                        return found;
-                }
-            }
-        }
     }
     return null;
 }

package/dist/core/prototype/shared/url/addresses.server.d.ts

@@ -0,0 +1,26 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { GenericDoc } from '../../types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/** The locales a page has an address in: `''` when the config has no localization. */
+export declare const addressLocales: (event: RequestEvent) => any;
+/** Gives these pages their address in every locale they have none in. */
+export declare const addAddresses: (args: {
+    event: RequestEvent;
+    config: BuiltCollection;
+    ids: string[];
+}) => Promise<void>;
+/**
+ * The document with its address as it now is: the read that produced it ran before a create or an
+ * update gave it one.
+ */
+export declare const withAddress: <T extends GenericDoc>(args: {
+    event: RequestEvent;
+    config: BuiltCollection;
+    doc: T;
+}) => Promise<T>;
+/**
+ * Once per process, on the first request: every page of a collection with `$url` gets the address
+ * it is missing. One query per collection and locale once they all have one. The requests after
+ * it are not held: nothing to await once it is done.
+ */
+export declare const ensureAddresses: (event: RequestEvent) => Promise<void>;

package/dist/core/prototype/shared/url/addresses.server.js

@@ -0,0 +1,119 @@
+import { walkFields } from '../../../fields/walk.js';
+import { logger } from '../../../logger.server.js';
+import { getValueAtPath } from '../../../../util/object.js';
+import { hasUrl } from './enabled.js';
+import { freeSlug, toSlug } from './format.server.js';
+import { formatRows, readForUrls } from './refresh.server.js';
+/** The locales a page has an address in: `''` when the config has no localization. */
+export const addressLocales = (event) => {
+    const codes = event.locals.rime.config.getLocalesCodes();
+    return codes.length ? codes : [''];
+};
+/**
+ * The slug a page starts with: the collection's own slug field when it has one, its title
+ * otherwise, its id as a last resort.
+ */
+const initialSlug = (config, doc) => {
+    for (const { field, path } of walkFields(config.fields)) {
+        if (field.type !== 'slug')
+            continue;
+        const value = toSlug(getValueAtPath(path, doc));
+        if (value)
+            return value;
+    }
+    return toSlug(doc.title) || doc.id;
+};
+/**
+ * Gives these pages their address in one locale: a slug free among their siblings, under their
+ * parent, then their url.
+ *
+ * A page is placed once its parent is, so a whole tree goes in, top first, in one call.
+ */
+const addAddressesIn = async (args) => {
+    const { event, config, ids, locale } = args;
+    const { paths } = event.locals.rime.adapter;
+    const docs = await readForUrls({ event, config, locale, ids });
+    const parentOf = (id) => docs.get(id)._parent ?? null;
+    let pending = ids.filter((id) => docs.has(id));
+    const inserted = [];
+    while (pending.length) {
+        const ready = pending.filter((id) => !pending.includes(parentOf(id) ?? ''));
+        if (!ready.length)
+            break;
+        for (const id of ready) {
+            const parentId = parentOf(id);
+            const taken = await paths.siblingSlugs({ slug: config.slug, locale, parentId });
+            const slug = freeSlug(initialSlug(config, docs.get(id)), taken);
+            inserted.push(...(await paths.insert({
+                slug: config.slug,
+                ownerId: id,
+                parentId,
+                rows: [{ locale, slug }]
+            })));
+        }
+        pending = pending.filter((id) => !ready.includes(id));
+    }
+    if (pending.length) {
+        logger.warn(`${config.slug}: no address for ${pending.join(', ')} in "${locale}"`);
+    }
+    await formatRows({ event, config, locale, rows: inserted, docs });
+};
+/** Gives these pages their address in every locale they have none in. */
+export const addAddresses = async (args) => {
+    const { event, config, ids } = args;
+    if (!ids.length)
+        return;
+    for (const locale of addressLocales(event)) {
+        const missing = new Set(await event.locals.rime.adapter.paths.missingOwners({ slug: config.slug, locale }));
+        const idsHere = ids.filter((id) => missing.has(id));
+        if (idsHere.length)
+            await addAddressesIn({ event, config, ids: idsHere, locale });
+    }
+};
+/**
+ * The document with its address as it now is: the read that produced it ran before a create or an
+ * update gave it one.
+ */
+export const withAddress = async (args) => {
+    const { event, config, doc } = args;
+    const [row] = await event.locals.rime.adapter.paths.get({
+        slug: config.slug,
+        ownerId: doc.id,
+        locale: doc.locale ?? ''
+    });
+    return { ...doc, url: row?.url ?? null, _urlPath: row?.path ?? null, _slug: row?.slug ?? null };
+};
+let ensured;
+let done = false;
+/**
+ * Once per process, on the first request: every page of a collection with `$url` gets the address
+ * it is missing. One query per collection and locale once they all have one. The requests after
+ * it are not held: nothing to await once it is done.
+ */
+export const ensureAddresses = async (event) => {
+    if (done)
+        return;
+    ensured ??= (async () => {
+        const { rime } = event.locals;
+        for (const config of rime.config.raw.collections) {
+            if (!hasUrl(config))
+                continue;
+            const missing = new Set();
+            for (const locale of addressLocales(event)) {
+                const ids = await rime.adapter.paths.missingOwners({ slug: config.slug, locale });
+                ids.forEach((id) => missing.add(id));
+            }
+            if (!missing.size)
+                continue;
+            logger.info(`${config.slug}: giving ${missing.size} pages their address`);
+            await addAddresses({ event, config, ids: [...missing] });
+        }
+    })().then(() => {
+        done = true;
+    }, (error) => {
+        // Tried again on the next request.
+        ensured = undefined;
+        logger.error(`addresses: ${error.message}`, error);
+    });
+    await ensured;
+};

package/dist/core/prototype/shared/url/doc-type.d.ts

@@ -0,0 +1,6 @@
+import type { DocTypeContribution } from '../../../dev/codegen/types/contributions.server.js';
+/**
+ * A document of a config with `$url` carries its url. A collection's also carries its address:
+ * the slugs down to it and its own slug. `null` until the page has one.
+ */
+export declare const urlDocType: (type: "collection" | "area") => DocTypeContribution;

package/dist/core/prototype/shared/url/doc-type.js

@@ -0,0 +1,9 @@
+/**
+ * A document of a config with `$url` carries its url. A collection's also carries its address:
+ * the slugs down to it and its own slug. `null` until the page has one.
+ */
+export const urlDocType = (type) => ({
+    members: type === 'collection'
+        ? ['url: string | null', '_urlPath: string | null', '_slug: string | null']
+        : ['url: string | null']
+});

package/dist/core/prototype/shared/url/format.server.d.ts

@@ -0,0 +1,27 @@
+import type { BuiltArea, BuiltCollection } from '../../../config/types.js';
+import type { GenericDoc } from '../../types.js';
+/**
+ * A page's url: `$url` with its path, slug, locale and document, made absolute against
+ * `PUBLIC_RIME_URL`.
+ *
+ * ```ts
+ * formatUrl({ config, doc, path: 'services/web', locale: 'en' }) // 'https://site.test/en/services/web'
+ * formatUrl({ config, doc, path: '', locale: '' })                // an area: no path, no slug
+ * ```
+ */
+export declare const formatUrl: (args: {
+    config: BuiltCollection | BuiltArea;
+    doc: GenericDoc;
+    path: string;
+    locale: string;
+}) => string;
+/** A slug made from any text: `'Web design!'` -> `'web-design'`. Empty when nothing is left. */
+export declare const toSlug: (text: unknown) => string;
+/**
+ * `wanted`, or the first of `wanted-2`, `wanted-3`… that no sibling holds.
+ *
+ * ```ts
+ * freeSlug('web', ['web', 'web-2']) // 'web-3'
+ * ```
+ */
+export declare const freeSlug: (wanted: string, taken: string[]) => string;