rimecms 0.32.1 → 1.0.0

package/dist/core/fields/util.js

@@ -1,8 +1,5 @@
-import { BlocksBuilder } from '../../fields/blocks/index.js';
-import { GroupFieldBuilder } from '../../fields/group/index.js';
-import { TabsBuilder } from '../../fields/tabs/index.js';
-import { TreeBuilder } from '../../fields/tree/index.js';
-import { normalizeFieldPath } from '../../util/path.js';
+import { normalizeFieldPath } from '../../util/string.js';
+import { matchesSegment, walkFields } from './walk.js';
 /**
  * Checks if a field is a presentative field (currently only separator fields).
  * Presentative fields are used for UI organization and don't store data.
@@ -36,31 +33,20 @@ export const isLiveField = (field) => field.live;
  *   ]}
  * ]);
  */
-export const emptyValuesFromFieldConfig = (arr) => {
-    return Object.fromEntries(arr.map((config) => {
-        let emptyValue;
-        // Handle group fields - create nested object structure
-        if (config instanceof GroupFieldBuilder) {
-            emptyValue = emptyValuesFromFieldConfig(config.get.fields.filter(isFormField));
-        }
-        // Handle tabs fields - create nested object structure for each tab
-        else if (config instanceof TabsBuilder) {
-            const tabsValue = {};
-            const tabs = config.get.tabs;
-            for (const tab of tabs) {
-                if ('fields' in tab) {
-                    tabsValue[tab.name] = emptyValuesFromFieldConfig(tab.get.fields.filter(isFormField));
-                }
-            }
-            emptyValue = tabsValue;
-        }
-        // Handle default values
-        else {
-            emptyValue = config.use.defaultValue();
-        }
-        return [config.name, emptyValue];
-    }));
-};
+export const emptyValuesFromFieldConfig = (fields) => Object.fromEntries(fields.filter(isFormField).map((config) => {
+    const nodes = config.use.nodes();
+    // A leaf, and a repeater with it: `#` means only a document can name the children, so an
+    // empty one holds the field's own default.
+    if (!nodes.length || nodes.some((node) => node.segment.includes('#'))) {
+        return [config.name, config.use.defaultValue()];
+    }
+    const value = {};
+    for (const node of nodes) {
+        const bucket = node.segment ? (value[node.segment] = {}) : value;
+        Object.assign(bucket, emptyValuesFromFieldConfig(node.fields));
+    }
+    return [config.name, value];
+}));
 /**
  * Converts a path with numeric indices to a regex pattern
  * Numbers between dots or between dot and colon are converted to \d+
@@ -91,49 +77,53 @@ export function pathToRegex(path) {
  *
  */
 export const getFieldAtPath = (path, fields) => {
-    const parts = path.split('.');
-    const findInFields = (currentFields, remainingParts) => {
-        if (remainingParts.length === 0)
+    const findInFields = (currentFields, parts) => {
+        if (!parts.length)
             return undefined;
-        const currentPart = remainingParts[0];
         for (const field of currentFields) {
-            // Handle tabs
-            if (field instanceof TabsBuilder) {
-                const tab = field.get.tabs.find((t) => t.name === currentPart);
-                if (tab) {
-                    return findInFields(tab.get.fields, remainingParts.slice(1));
+            const nodes = field.use.nodes();
+            // A container with no name of its own: its branches are the segment (tabs).
+            if (!field.name) {
+                for (const node of nodes) {
+                    if (!matchesSegment(node.segment, parts[0]))
+                        continue;
+                    const found = findInFields(node.fields, parts.slice(1));
+                    if (found)
+                        return found;
                 }
                 continue;
             }
-            // Handle regular fields
-            if (isFormField(field)) {
-                if (field.name === currentPart) {
-                    if (remainingParts.length === 1) {
-                        return field;
-                    }
-                    if (field instanceof GroupFieldBuilder) {
-                        return findInFields(field.get.fields, remainingParts.slice(1));
-                    }
-                    // Handle blocks
-                    if (field instanceof BlocksBuilder && remainingParts.length > 1) {
-                        // const blockPartPattern = /:[a-zA-Z0-9]+/
-                        const blockType = remainingParts[1].split(':')[1];
-                        if (blockType) {
-                            const block = field.get.blocks.find((b) => b.name === blockType);
-                            if (block) {
-                                return findInFields(block.get.fields, remainingParts.slice(2));
-                            }
-                        }
-                    }
-                    if (field instanceof TreeBuilder) {
-                        return findInFields(field.get.fields, remainingParts.slice(2));
-                    }
+            if (field.name !== parts[0])
+                continue;
+            if (parts.length === 1)
+                return field;
+            for (const node of nodes) {
+                // A branch that adds no segment: the rest of the path is already inside it.
+                if (!node.segment) {
+                    const found = findInFields(node.fields, parts.slice(1));
+                    if (found)
+                        return found;
+                    continue;
+                }
+                if (!matchesSegment(node.segment, parts[1]))
+                    continue;
+                // A repeating branch stays itself through `_children.<index>`, however deep.
+                let rest = parts.slice(2);
+                while (node.repeatVia &&
+                    rest[0] === node.repeatVia &&
+                    rest[1] !== undefined &&
+                    matchesSegment(node.segment, rest[1])) {
+                    rest = rest.slice(2);
                 }
+                const found = findInFields(node.fields, rest);
+                if (found)
+                    return found;
             }
+            return undefined;
         }
         return undefined;
     };
-    return findInFields(fields, parts);
+    return findInFields(fields, path.split('.'));
 };
 /**
  * Traverses a FieldBuilder[] tree and returns the subset of builders to pass to
@@ -149,60 +139,53 @@ export function getFieldListAtPath(fieldPath, fields, parentPath = '') {
     const dotIndex = fieldPath.indexOf('.');
     const head = dotIndex === -1 ? fieldPath : fieldPath.slice(0, dotIndex);
     const tail = dotIndex === -1 ? '' : fieldPath.slice(dotIndex + 1);
-    const isEndpoint = fieldPath.split('.').length === 1;
-    const nextParentPath = normalizeFieldPath(`${parentPath}${parentPath ? '.' : ''}${head}`);
+    const isEndpoint = !tail;
+    const below = (path, segment) => normalizeFieldPath(path ? `${path}.${segment}` : segment);
     for (const field of fields) {
-        // ── Tabs container: navigate into the matching tab
-        if (field instanceof TabsBuilder) {
-            const tab = field.field.tabs.find((t) => t.name === head);
-            if (!tab)
+        const nodes = field.use.nodes();
+        // A container with no name of its own: its branches are the segment (tabs).
+        if (!field.name) {
+            const node = nodes.find((candidate) => matchesSegment(candidate.segment, head));
+            if (!node)
                 continue;
-            if (isEndpoint) {
-                // Path targets the tab → return all its inner fields
-                return { fields: tab.get.fields, path: nextParentPath };
-            }
-            return getFieldListAtPath(tail, tab.get.fields, nextParentPath);
+            const path = below(parentPath, head);
+            return isEndpoint
+                ? { fields: node.fields, path }
+                : getFieldListAtPath(tail, node.fields, path);
         }
-        if (!isFormField(field))
+        if (field.name !== head)
             continue;
-        // ── Group field: navigate into children
-        if (field instanceof GroupFieldBuilder && field.name === head) {
-            const children = field.get.fields;
-            if (isEndpoint)
-                return { fields: children, path: nextParentPath };
-            return getFieldListAtPath(tail, children, nextParentPath);
+        const own = below(parentPath, head);
+        // A branch that adds no segment: the rest of the path is already inside it (group).
+        const transparent = nodes.find((node) => !node.segment);
+        if (transparent) {
+            return isEndpoint
+                ? { fields: transparent.fields, path: own }
+                : getFieldListAtPath(tail, transparent.fields, own);
         }
-        // —— Blocks
-        if (field instanceof BlocksBuilder && field.name === head) {
-            const blockType = tail.split('.')[0]?.split(':')[1];
-            const isInnerBlockLookup = tail.split('.').length > 1;
-            const nextParentPathWithBlockIndex = `${nextParentPath}.${tail.split('.')[0]}`;
-            if (blockType) {
-                const block = field.get.blocks.find((b) => b.name === blockType);
-                if (!isInnerBlockLookup && block?.get.fields) {
-                    return {
-                        fields: block.get.fields,
-                        path: normalizeFieldPath(nextParentPathWithBlockIndex)
-                    };
-                }
-                if (block) {
-                    return getFieldListAtPath(tail.split('.').slice(1).join('.'), block.get.fields, normalizeFieldPath(nextParentPathWithBlockIndex));
-                }
-            }
-            return { fields: [field], path: parentPath };
-        }
-        // Tree
-        if (field instanceof TreeBuilder && field.name === head) {
-            const children = field.get.fields;
-            const nextParentPathWithIndex = `${nextParentPath}.${tail.split('.')[0]}`;
-            if (isEndpoint)
-                return { fields: children, path: nextParentPath };
-            return getFieldListAtPath(tail.split('.').slice(1).join('.'), children, nextParentPathWithIndex);
+        if (isEndpoint) {
+            // Nothing left to pick a branch with. One unnamed branch is still the answer — a tree row;
+            // several named ones are not — a blocks field answers with itself.
+            const only = nodes.length === 1 && !nodes[0].segment.includes(':') ? nodes[0] : undefined;
+            return only ? { fields: only.fields, path: own } : { fields: [field], path: parentPath };
         }
-        // Direct unique field match
-        if (isEndpoint && isFormField(field) && field.name === fieldPath) {
+        const parts = tail.split('.');
+        const node = nodes.find((candidate) => matchesSegment(candidate.segment, parts[0]));
+        if (!node)
             return { fields: [field], path: parentPath };
+        // A repeating branch stays itself through `_children.<index>`, however deep.
+        let rest = parts.slice(1);
+        let path = below(own, parts[0]);
+        while (node.repeatVia &&
+            rest[0] === node.repeatVia &&
+            rest[1] !== undefined &&
+            matchesSegment(node.segment, rest[1])) {
+            path = `${path}.${rest[0]}.${rest[1]}`;
+            rest = rest.slice(2);
         }
+        return rest.length
+            ? getFieldListAtPath(rest.join('.'), node.fields, path)
+            : { fields: node.fields, path };
     }
     console.warn(`[LiveEditPanel] fieldPath "${fieldPath}" not found in config fields`);
     return { fields, path: parentPath };
@@ -218,10 +201,7 @@ export function getFieldListAtPath(fieldPath, fields, parentPath = '') {
  *
  * Top-level only, matching the generator: a nested field cannot be split off its parent.
  */
-export const baseFieldNames = (config) => config.fields
-    .filter(isFormField)
-    .filter((field) => field.get.root)
-    .map((field) => field.name);
+export const baseFieldNames = (config) => config.fields.filter((field) => field.get.root).map((field) => field.name);
 /**
  * The fields a read resolves into the document they reference, with the column each one is
  * stored in. A field opts in with `$references(slug, { resolve: true })`.
@@ -237,31 +217,39 @@ export const baseFieldNames = (config) => config.fields
  * Walks tabs and groups, whose columns sit on the owner's row. Blocks and tree rows are their
  * own tables and are not walked.
  */
+/**
+ * The resolved references a reader may see, by path — what a read asks the adapter to join. A
+ * reference the pipeline would drop for this reader is not joined for nothing.
+ */
+export const readableReferences = (fields, user) => resolvedReferencesOf(fields)
+    .filter((reference) => reference.field.use.accessRead(user))
+    .map((reference) => reference.path);
+const resolvedReferencesMemo = new WeakMap();
 export const resolvedReferencesOf = (fields, parentPath = '') => {
-    const prefix = parentPath ? `${parentPath}.` : '';
-    const found = [];
-    for (const field of fields) {
-        if (field instanceof TabsBuilder) {
-            for (const tab of field.get.tabs) {
-                found.push(...resolvedReferencesOf(tab.get.fields, `${prefix}${tab.name}`));
-            }
-            continue;
+    // A config's fields do not change once built, and this is asked once per query and once per
+    // document read: answered once per list of fields.
+    if (!parentPath) {
+        let found = resolvedReferencesMemo.get(fields);
+        if (!found) {
+            found = collectResolvedReferences(fields, '');
+            resolvedReferencesMemo.set(fields, found);
         }
-        if (!isFormField(field))
-            continue;
-        if (field instanceof GroupFieldBuilder) {
-            found.push(...resolvedReferencesOf(field.get.fields, `${prefix}${field.name}`));
+        return found;
+    }
+    return collectResolvedReferences(fields, parentPath);
+};
+const collectResolvedReferences = (fields, parentPath) => {
+    const found = [];
+    for (const { field, path } of walkFields(fields, { path: parentPath, determinate: true })) {
+        if (!isFormField(field) || !field._references?.resolve)
             continue;
-        }
-        if (field._references?.resolve) {
-            const path = `${prefix}${field.name}`;
-            found.push({
-                path,
-                column: path.replace(/\./g, '__'),
-                root: field.get.root,
-                to: field._references.table
-            });
-        }
+        found.push({
+            field,
+            path,
+            column: path.replace(/\./g, '__'),
+            root: field.get.root,
+            to: field._references.table
+        });
     }
     return found;
 };

package/dist/core/fields/walk.d.ts

@@ -0,0 +1,44 @@
+import type { FieldBuilder } from './builders/field-builder.js';
+/** A field the walk reached, the path it sits at, and the data there when the walk has data. */
+export type Visit = {
+    field: FieldBuilder;
+    path: string;
+    value: unknown;
+};
+/** The document grammar's join. A joiner is never handed an empty part — a branch that
+ *  contributes no segment keeps its parent's path — so it only guards the empty parent. */
+export declare const joinPath: (parent: string, part: string) => string;
+export type WalkOptions = {
+    path?: string;
+    /** The schema generator joins with `__`. */
+    join?: (parent: string, part: string) => string;
+    /** Skip branches whose segment holds a `#` — a path no config alone can name. */
+    determinate?: boolean;
+};
+/**
+ * Every field the config declares, parents before children, siblings in declaration order.
+ *
+ * ```
+ * tabs(tab('meta').fields(group('seo').fields(text('title'))))
+ *   ->  meta.seo  ·  meta.seo.title
+ * ```
+ */
+export declare function walkFields(fields: FieldBuilder[], { path, join, determinate }?: WalkOptions): Generator<Visit>;
+/**
+ * Every field a document actually carries, at the path its value sits at. A named field the data
+ * does not hold contributes nothing.
+ *
+ * ```
+ * blocks('layout', [block('hero').fields(text('title'))])
+ *   { layout: [ { type: 'hero', title: 'x' } ] }  ->  layout  ·  layout.0:hero.title
+ * ```
+ */
+export declare function walkValues(fields: FieldBuilder[], data: unknown, { path, join }?: WalkOptions): Generator<Visit>;
+/**
+ * Whether one concrete segment is the branch a declared segment stands for.
+ *
+ * ```
+ * '#:hero' matches '0:hero'  ·  '#' matches '7'  ·  'meta' matches only 'meta'
+ * ```
+ */
+export declare const matchesSegment: (pattern: string, segment: string) => boolean;

package/dist/core/fields/walk.js

@@ -0,0 +1,55 @@
+import { isObjectLiteral } from '../../util/object.js';
+/** The document grammar's join. A joiner is never handed an empty part — a branch that
+ *  contributes no segment keeps its parent's path — so it only guards the empty parent. */
+export const joinPath = (parent, part) => (parent ? `${parent}.${part}` : part);
+/**
+ * Every field the config declares, parents before children, siblings in declaration order.
+ *
+ * ```
+ * tabs(tab('meta').fields(group('seo').fields(text('title'))))
+ *   ->  meta.seo  ·  meta.seo.title
+ * ```
+ */
+export function* walkFields(fields, { path = '', join = joinPath, determinate = false } = {}) {
+    for (const field of fields) {
+        const own = field.name ? join(path, field.name) : path;
+        yield { field, path: own, value: undefined };
+        for (const node of field.use.nodes()) {
+            if (determinate && node.segment.includes('#'))
+                continue;
+            const below = node.segment ? join(own, node.segment) : own;
+            yield* walkFields(node.fields, { path: below, join, determinate });
+        }
+    }
+}
+/**
+ * Every field a document actually carries, at the path its value sits at. A named field the data
+ * does not hold contributes nothing.
+ *
+ * ```
+ * blocks('layout', [block('hero').fields(text('title'))])
+ *   { layout: [ { type: 'hero', title: 'x' } ] }  ->  layout  ·  layout.0:hero.title
+ * ```
+ */
+export function* walkValues(fields, data, { path = '', join = joinPath } = {}) {
+    for (const field of fields) {
+        if (field.name && !(isObjectLiteral(data) && field.name in data))
+            continue;
+        const own = field.name ? join(path, field.name) : path;
+        const value = field.name ? data[field.name] : data;
+        yield { field, path: own, value };
+        for (const node of field.use.nodesFor(value)) {
+            const below = node.segment ? join(own, node.segment) : own;
+            yield* walkValues(node.fields, node.value, { path: below, join });
+        }
+    }
+}
+const escapeRegex = (str) => str.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+/**
+ * Whether one concrete segment is the branch a declared segment stands for.
+ *
+ * ```
+ * '#:hero' matches '0:hero'  ·  '#' matches '7'  ·  'meta' matches only 'meta'
+ * ```
+ */
+export const matchesSegment = (pattern, segment) => new RegExp(`^${pattern.split('#').map(escapeRegex).join('\\d+')}$`).test(segment);

package/dist/core/handler.server.js

@@ -5,11 +5,15 @@ import { logger } from './logger.server.js';
 import {} from '@sveltejs/kit';
 import { svelteKitHandler } from 'better-auth/svelte-kit';
 import { createPluginsHandler } from './plugins/plugins.server.js';
+import { ensureAddresses } from './prototype/shared/url/addresses.server.js';
 import { handleRoutes } from './routes/handler.server.js';
 function createCMSHandler(rime) {
     const handleCMS = async ({ event, resolve }) => {
         logger.info(`${event.request.method} ${event.url.pathname}`);
         event.locals.rime = rime.createRimeContext(event);
+        // Once per process: pages written before their collection kept addresses get theirs.
+        if (!building)
+            await ensureAddresses(event);
         return svelteKitHandler({ event, resolve, auth: rime.auth, building });
     };
     return handleCMS;

package/dist/core/i18n/context.d.ts

@@ -0,0 +1,5 @@
+import type { I18n } from './index.js';
+/** Puts a translator in Svelte context, for `getI18nContext` in every component below. */
+export declare const setI18nContext: (i18n: I18n) => I18n;
+/** The translator the nearest `setI18nContext` above put in context. */
+export declare const getI18nContext: () => I18n;

package/dist/core/i18n/context.js

@@ -0,0 +1,6 @@
+import { getContext, setContext } from 'svelte';
+const KEY = 'rime:i18n';
+/** Puts a translator in Svelte context, for `getI18nContext` in every component below. */
+export const setI18nContext = (i18n) => setContext(KEY, i18n);
+/** The translator the nearest `setI18nContext` above put in context. */
+export const getI18nContext = () => getContext(KEY);

package/dist/core/i18n/en/common.d.ts

@@ -66,7 +66,34 @@ declare namespace _default {
     export let save: string;
     export let search_a: string;
     export let search: string;
+    export let language: string;
+    export let switch_to_language: string;
+    export let commands: string;
+    export let collection: string;
+    export let search_in: string;
+    export let show_as_list: string;
+    export let show_as_grid: string;
+    export let show_as_tree: string;
+    export let mark_as: string;
+    export let type_a_command: string;
+    export let nothing_found: string;
+    export let palette_move: string;
+    export let palette_run: string;
+    export let palette_close: string;
+    export let profile: string;
+    export let sign_out: string;
+    export let go_to: string;
+    export let document: string;
+    export let collections: string;
+    export let areas: string;
+    export let text: string;
     export let select_all: string;
+    export let collection_count: string;
+    export let collection_count_files: string;
+    export let collection_deselect_all: string;
+    export let collection_display: string;
+    export let collection_select: string;
+    export let collection_upload: string;
     export let sendPasswordResetLink: string;
     export let signin: string;
     export let someone: string;
@@ -78,7 +105,51 @@ declare namespace _default {
     export let view_all: string;
     export let view_page: string;
     export let view_site: string;
+    export let good_morning: string;
+    export let good_afternoon: string;
+    export let good_evening: string;
+    export let no_documents_yet: string;
+    export let create_first_one: string;
+    export let all: string;
+    export let author: string;
+    export let status: string;
+    export let title: string;
+    export let updated: string;
+    export let sort_by: string;
+    export let collection_count_drafts: string;
+    export let drafts_waiting: string;
+    export let drop_anywhere: string;
+    export let drop_to_upload_into: string;
+    export let media_kind_image: string;
+    export let media_kind_video: string;
+    export let media_kind_audio: string;
+    export let media_kind_document: string;
+    export let media_kind_other: string;
+    export let time_now: string;
+    export let time_minutes_ago: string;
+    export let time_hours_ago: string;
+    export let time_yesterday: string;
+    export let time_days_ago: string;
     export let welcome: string;
     export let your_auto_save: string;
+    export let untitled: string;
+    export let edited: string;
+    export let edited_by: string;
+    export let document_actions: string;
+    export let copy_id: string;
+    export let id_copied: string;
+    export let created_on: string;
+    export let updated_on: string;
+    export let by_user: string;
+    export let id: string;
+    export let change_url: string;
+    export let copy_url: string;
+    export let url_copied: string;
+    export let url_changed: string;
+    export let url_address: string;
+    export let url_on_published: string;
+    export let url_slug_required: string;
+    export let url_slug_taken: string;
+    export let under_this_page: string;
 }
 export default _default;

package/dist/core/i18n/en/common.js

@@ -67,7 +67,34 @@ export default {
   save: 'Save',
   search_a: 'Search a $1...',
   search: 'Search $1...',
+  language: 'Language',
+  switch_to_language: 'Switch to $1',
+  commands: 'Commands',
+  collection: 'Collection',
+  search_in: 'Search in $1',
+  show_as_list: 'Show as a list',
+  show_as_grid: 'Show as a grid',
+  show_as_tree: 'Show as a tree',
+  mark_as: 'Mark as $1',
+  type_a_command: 'A command, a document…',
+  nothing_found: 'Nothing found',
+  palette_move: 'to move',
+  palette_run: 'to run',
+  palette_close: 'to close',
+  profile: 'Profile',
+  sign_out: 'Sign out',
+  go_to: 'Go to',
+  document: 'Document',
+  collections: 'Collections',
+  areas: 'Areas',
+  text: 'Text',
   select_all: 'Select all',
+  collection_count: '$1 {document|document|documents}',
+  collection_count_files: '$1 {file|file|files}',
+  collection_deselect_all: 'Deselect all',
+  collection_display: 'Display',
+  collection_select: 'Select',
+  collection_upload: 'Upload',
   sendPasswordResetLink: 'Send a password reset link',
   signin: 'Sign In',
   someone: 'Someone',
@@ -79,6 +106,50 @@ export default {
   view_all: 'View all',
   view_page: 'View page',
   view_site: 'View website',
+  good_morning: 'Good morning, $1',
+  good_afternoon: 'Good afternoon, $1',
+  good_evening: 'Good evening, $1',
+  no_documents_yet: 'No $1 yet.',
+  create_first_one: 'Create the first one',
+  all: 'All',
+  author: 'Author',
+  status: 'Status',
+  title: 'Title',
+  updated: 'Updated',
+  sort_by: 'Sort by $1',
+  collection_count_drafts: '$1 {draft|draft|drafts}',
+  drafts_waiting: '$1 {draft|draft|drafts} waiting',
+  drop_anywhere: 'drop files anywhere to upload them',
+  drop_to_upload_into: 'Drop to upload into $1',
+  media_kind_image: 'Images',
+  media_kind_video: 'Videos',
+  media_kind_audio: 'Audio',
+  media_kind_document: 'Documents',
+  media_kind_other: 'Other files',
+  time_now: 'Just now',
+  time_minutes_ago: '$1 min ago',
+  time_hours_ago: '$1 h ago',
+  time_yesterday: 'Yesterday',
+  time_days_ago: '$1 d ago',
   welcome: 'Welcome',
-  your_auto_save: 'Your auto-save'
+  your_auto_save: 'Your auto-save',
+  untitled: 'Untitled',
+  edited: 'edited $1',
+  edited_by: 'edited by $1, $2',
+  document_actions: 'Document actions',
+  copy_id: 'Copy the ID',
+  id_copied: 'ID copied',
+  created_on: 'Created $1',
+  updated_on: 'Updated $1',
+  by_user: 'by $1',
+  id: 'ID',
+  change_url: 'Change url',
+  copy_url: 'Copy the url',
+  url_copied: 'Url copied',
+  url_changed: 'Url changed',
+  url_address: 'Address',
+  url_on_published: 'The url changes on the published version.',
+  url_slug_required: 'The address needs at least one letter or digit.',
+  url_slug_taken: 'Another page at this level already uses this address.',
+  under_this_page: 'Under this page'
 };