rimecms 0.31.5 → 0.32.0

package/dist/core/fields/util.js

@@ -2,7 +2,7 @@ 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/doc.js';
+import { normalizeFieldPath } from '../../util/path.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.
@@ -207,3 +207,86 @@ export function getFieldListAtPath(fieldPath, fields, parentPath = '') {
     console.warn(`[LiveEditPanel] fieldPath "${fieldPath}" not found in config fields`);
     return { fields, path: parentPath };
 }
+/**
+ * The fields a config keeps on its base row rather than on its versions table — whatever is marked
+ * `$root()`.
+ *
+ * Read off the config, never a list of names, because the schema generator splits the two tables
+ * by the same flag: the base table gets `filter((f) => f.get.root)`, the versions table gets the rest. A
+ * name-matching list would silently drop any field marked by something other than the two features
+ * whose names happened to be in it — there is no versions column to fall back to.
+ *
+ * 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);
+/**
+ * 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 })`.
+ *
+ * ```
+ * text('updatedBy').$references('staff', { resolve: true })
+ * // { path: 'updatedBy', column: 'updatedBy', root: false, to: 'staff' }
+ *
+ * group('meta').fields(text('owner').$references('staff', { resolve: true }))
+ * // { path: 'meta.owner', column: 'meta__owner', root: false, to: 'staff' }
+ * ```
+ *
+ * Walks tabs and groups, whose columns sit on the owner's row. Blocks and tree rows are their
+ * own tables and are not walked.
+ */
+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;
+        }
+        if (!isFormField(field))
+            continue;
+        if (field instanceof GroupFieldBuilder) {
+            found.push(...resolvedReferencesOf(field.get.fields, `${prefix}${field.name}`));
+            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
+            });
+        }
+    }
+    return found;
+};
+/**
+ * Splits a write into the half that belongs on the base row and the half that belongs on the
+ * content row.
+ *
+ * Lived in `adapter-sqlite/util.server.ts` as `extractRootData`, which is one layer too low: which
+ * fields are base fields is a fact about the field configs, and every adapter would have to
+ * re-derive it. It is also where the write plan needs it (core/pipeline/write-plan.ts), which is
+ * above any adapter.
+ *
+ * Non-mutating, unlike the version it replaces — that one deleted the base keys out of the
+ * caller's own `data`, which `runUpdate` then went on to hand to `persistRelational`. Nothing
+ * depended on that (blocks, tree and relations resolve against `incomingPaths`, and no base field
+ * is one), but a write that quietly empties its argument is a trap either way.
+ */
+export const splitRootData = (data, config) => {
+    const base = {};
+    const content = { ...data };
+    for (const name of baseFieldNames(config)) {
+        if (name in content) {
+            base[name] = content[name];
+            delete content[name];
+        }
+    }
+    return { base, content };
+};

package/dist/core/fields/validate.js

@@ -0,0 +1,171 @@
+import { RimeFormError } from '../errors/index.js';
+/**
+ * Validates a password string against security requirements.
+ * Checks for minimum length, lowercase, uppercase, numbers, and special characters.
+ *
+ * @example
+ * // Returns true for a valid password
+ * password("Secure1Password!");
+ *
+ * // Returns an error code for an invalid password
+ * password("weak"); // Returns RimeFormError.PASSWORD_MIN_8
+ */
+export const password = (value) => {
+    if (typeof value !== 'string') {
+        return RimeFormError.NOT_A_STRING;
+    }
+    if (value.length < 8) {
+        return RimeFormError.PASSWORD_MIN_8;
+    }
+    else if (!/[a-z]/.test(value)) {
+        return RimeFormError.PASSWORD_LOWERCASE_MISSING;
+    }
+    else if (!/[A-Z]/.test(value)) {
+        return RimeFormError.PASSWORD_UPPERCASE_MISSING;
+    }
+    else if (!/\d/.test(value)) {
+        return RimeFormError.PASSWORD_NUMBER_MISSING;
+    }
+    else if (!/[#.?"'(§)_=!+:;@$%^&*-]/.test(value)) {
+        return RimeFormError.PASSWORD_SPECIAL_CHAR_MISSING;
+    }
+    return true;
+};
+/**
+ * Validates an email address string.
+ * Ensures the email follows standard format with proper characters and domain structure.
+ *
+ * @example
+ * // Returns true for a valid email
+ * email("user@example.com");
+ *
+ * // Returns an error code for an invalid email
+ * email("invalid-email"); // Returns RimeFormError.INVALID_EMAIL
+ */
+export const email = (value) => {
+    if (typeof value !== 'string') {
+        return RimeFormError.NOT_A_STRING;
+    }
+    // This regex ensures:
+    // 1. Starts with letter/number
+    // 2. Can contain .-_ between letters/numbers
+    // 3. Can't have consecutive dots
+    // 4. Can't end with .-_ before @
+    if (!/^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?@[^\s@]+\.[^\s@]+$/.test(value)) {
+        return RimeFormError.INVALID_EMAIL;
+    }
+    return true;
+};
+/**
+ * Validates a telephone number string.
+ * Ensures the phone number contains only digits, spaces, and the plus sign.
+ *
+ * @example
+ * // Returns true for a valid phone number
+ * tel("+1 555 123 4567");
+ *
+ * // Returns an error code for an invalid phone number
+ * tel("abc123"); // Returns RimeFormError.INVALID_PHONE
+ */
+export const tel = (value) => {
+    if (typeof value !== 'string') {
+        return RimeFormError.NOT_A_STRING;
+    }
+    if (!/^[+\d\s]+$/.test(value)) {
+        return RimeFormError.INVALID_PHONE;
+    }
+    return true;
+};
+/**
+ * Validates a URL string.
+ * Ensures the URL follows standard HTTP/HTTPS format with proper domain structure.
+ *
+ * @example
+ * // Returns true for a valid URL
+ * url("https://example.com/page");
+ *
+ * // Returns an error code for an invalid URL
+ * url("not-a-url"); // Returns RimeFormError.INVALID_URL
+ */
+export const url = (value) => {
+    if (typeof value !== 'string') {
+        return RimeFormError.NOT_A_STRING;
+    }
+    try {
+        const url = new URL(value);
+        // Only allow http and https protocols
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            return RimeFormError.INVALID_URL;
+        }
+        return true;
+    }
+    catch {
+        return RimeFormError.INVALID_URL;
+    }
+};
+/**
+ * Validates a slug string.
+ * Ensures the slug contains only lowercase letters, numbers, and hyphens.
+ *
+ * @example
+ * // Returns true for a valid slug
+ * slug("my-page-slug-123");
+ *
+ * // Returns an error code for an invalid slug
+ * slug("Invalid Slug!"); // Returns RimeFormError.INVALID_SLUG
+ */
+export const slug = (value) => {
+    if (typeof value !== 'string') {
+        return RimeFormError.NOT_A_STRING;
+    }
+    if (!/^[a-z0-9-]+$/.test(value)) {
+        return RimeFormError.INVALID_SLUG;
+    }
+    return true;
+};
+/**
+ * Validates a link object with different validation based on link type.
+ * Supports tel, email, url, and anchor link types.
+ *
+ * @example
+ * // Returns true for a valid email link
+ * link({ type: 'email', value: 'user@example.com' });
+ *
+ * // Returns an error string for an invalid URL link
+ * link({ type: 'url', value: 'invalid-url' }); // Returns "url::INVALID_URL"
+ */
+export const link = (link) => {
+    const { type, value } = link;
+    if (value === '')
+        return true;
+    if (type === 'tel') {
+        const valid = validate.tel(value);
+        return typeof valid === 'string' ? `tel::${valid}` : true;
+    }
+    if (type === 'email') {
+        const valid = validate.email(value);
+        return typeof valid === 'string' ? `email::${valid}` : true;
+    }
+    if (type === 'url') {
+        const valid = validate.url(value);
+        return typeof valid === 'string' ? `url::${valid}` : true;
+    }
+    if (type === 'anchor') {
+        const valid = validate.slug(value);
+        return typeof valid === 'string' ? `anchor::${valid}` : true;
+    }
+    return true;
+};
+/**
+ * Collection of validation utility functions for common data types.
+ * Each function returns true if the value is valid, or an error code/message if invalid.
+ */
+const validate = {
+    password,
+    email,
+    slug,
+    url,
+    tel,
+    link
+};
+export default validate;

package/dist/core/handler.server.d.ts

@@ -0,0 +1,4 @@
+import { type Handle } from '@sveltejs/kit';
+import type { Config } from './config/types.js';
+import type { Rime } from './rime.server.js';
+export default function <const C extends Config>(rime: Promise<Rime<C>>): Promise<Handle[]>;

package/dist/core/handler.server.js

@@ -0,0 +1,25 @@
+import { building } from '$app/environment';
+import { handleAuth } from './auth/handler/index.server.js';
+import { handleCORS } from './cors/handler.server.js';
+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 { 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);
+        return svelteKitHandler({ event, resolve, auth: rime.auth, building });
+    };
+    return handleCMS;
+}
+export default async function (rime) {
+    return [
+        createCMSHandler(await rime),
+        handleCORS,
+        handleAuth,
+        ...createPluginsHandler(await rime),
+        handleRoutes
+    ];
+}

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

@@ -1,6 +1,15 @@
 declare namespace _default {
     export let api_key_dialog_title: string;
     export let api_key_dialog_text: string;
+    export let auto_save_banner_other: string;
+    export let auto_save_banner_own: string;
+    export let auto_save_by: string;
+    export let auto_save_discard: string;
+    export let auto_save_open: string;
+    export let auto_save_paused: string;
+    export let auto_save_resume: string;
+    export let auto_saved_at: string;
+    export let auto_saving: string;
     export let browse: string;
     export let bulk_upload_dialog_title: string;
     export let cancel: string;
@@ -12,10 +21,16 @@ declare namespace _default {
     export let create_folder: string;
     export let create: string;
     export let created_at: string;
+    export let created_by: string;
+    export let updated_by: string;
     let _delete: string;
     export { _delete as delete };
     export let delete_dialog_title: string;
     export let delete_dialog_text: string;
+    export let delete_document: string;
+    export let delete_version: string;
+    export let delete_version_dialog_title: string;
+    export let delete_version_dialog_text: string;
     export let duplicate: string;
     export let duplicate_success: string;
     export let doc_deleted: string;
@@ -54,13 +69,16 @@ declare namespace _default {
     export let select_all: string;
     export let sendPasswordResetLink: string;
     export let signin: string;
+    export let someone: string;
     export let unsaved_dialog_title: string;
     export let unsaved_dialog_text: string;
     export let version_created: string;
+    export let version_deleted: string;
     export let versions_history: string;
     export let view_all: string;
     export let view_page: string;
     export let view_site: string;
     export let welcome: string;
+    export let your_auto_save: string;
 }
 export default _default;

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

@@ -2,6 +2,15 @@ export default {
   api_key_dialog_title: 'Your API Key',
   api_key_dialog_text:
     'This API key will only be shown once and cannot be retrieved later. Please copy it and store it securely on your server.',
+  auto_save_banner_other: '$1 has a more recent auto-save from $2.',
+  auto_save_banner_own: 'You have a more recent auto-save from $1.',
+  auto_save_by: 'Auto-save by $1',
+  auto_save_discard: 'Discard',
+  auto_save_open: 'Open',
+  auto_save_paused: 'Auto-save paused: $1',
+  auto_save_resume: 'Resume',
+  auto_saved_at: 'Auto-saved $1',
+  auto_saving: 'Saving…',
   browse: 'browse',
   bulk_upload_dialog_title: 'Bulk upload',
   cancel: 'Cancel',
@@ -13,9 +22,16 @@ export default {
   create_folder: 'New folder',
   create: 'Create',
   created_at: 'Created',
+  created_by: 'Created by',
+  updated_by: 'Updated by',
   delete: 'Delete $1',
   delete_dialog_title: 'Delete $1',
   delete_dialog_text: 'You are about to delete $1, press delete to confirm the operation.',
+  delete_document: 'Delete the document',
+  delete_version: 'Delete this version',
+  delete_version_dialog_title: 'Delete this version',
+  delete_version_dialog_text:
+    'You are about to delete this version of the document. The other versions stay.',
   duplicate: 'Duplicate',
   duplicate_success: 'Duplicated successfully',
   doc_deleted: 'Document deleted',
@@ -54,12 +70,15 @@ export default {
   select_all: 'Select all',
   sendPasswordResetLink: 'Send a password reset link',
   signin: 'Sign In',
+  someone: 'Someone',
   unsaved_dialog_title: 'Changes unsaved',
   unsaved_dialog_text: 'There are unsaved modifications in the document.',
   version_created: 'New version created',
+  version_deleted: 'Version deleted',
   versions_history: 'Versions history',
   view_all: 'View all',
   view_page: 'View page',
   view_site: 'View website',
-  welcome: 'Welcome'
+  welcome: 'Welcome',
+  your_auto_save: 'Your auto-save'
 };

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

@@ -1,6 +1,15 @@
 declare namespace _default {
     export let api_key_dialog_title: string;
     export let api_key_dialog_text: string;
+    export let auto_save_banner_other: string;
+    export let auto_save_banner_own: string;
+    export let auto_save_by: string;
+    export let auto_save_discard: string;
+    export let auto_save_open: string;
+    export let auto_save_paused: string;
+    export let auto_save_resume: string;
+    export let auto_saved_at: string;
+    export let auto_saving: string;
     export let browse: string;
     export let bulk_upload_dialog_title: string;
     export let cancel: string;
@@ -9,12 +18,18 @@ declare namespace _default {
     export let create_first: string;
     export let create_new: string;
     export let created_at: string;
+    export let created_by: string;
+    export let updated_by: string;
     export let create_folder: string;
     export let create: string;
     let _delete: string;
     export { _delete as delete };
     export let delete_dialog_title: string;
     export let delete_dialog_text: string;
+    export let delete_document: string;
+    export let delete_version: string;
+    export let delete_version_dialog_title: string;
+    export let delete_version_dialog_text: string;
     export let duplicate: string;
     export let duplicate_success: string;
     export let doc_deleted: string;
@@ -53,9 +68,11 @@ declare namespace _default {
     export let select_all: string;
     export let sendPasswordResetLink: string;
     export let signin: string;
+    export let someone: string;
     export let unsaved_dialog_title: string;
     export let unsaved_dialog_text: string;
     export let version_created: string;
+    export let version_deleted: string;
     export let versions_history: string;
     export let versions: string;
     export let view_all: string;
@@ -63,5 +80,6 @@ declare namespace _default {
     export let view_site: string;
     export let welcome: string;
     export let confirmPassword: string;
+    export let your_auto_save: string;
 }
 export default _default;

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

@@ -2,6 +2,15 @@ export default {
   api_key_dialog_title: 'Votre clé API',
   api_key_dialog_text:
     "Cette clé API ne sera affichée qu'une seule fois et ne pourra pas être récupérée ultérieurement. Veuillez la copier et la stocker en lieu sûr sur votre serveur.",
+  auto_save_banner_other: '$1 a un enregistrement automatique plus récent du $2.',
+  auto_save_banner_own: 'Vous avez un enregistrement automatique plus récent du $1.',
+  auto_save_by: 'Enregistrement automatique de $1',
+  auto_save_discard: 'Abandonner',
+  auto_save_open: 'Ouvrir',
+  auto_save_paused: 'Enregistrement automatique en pause : $1',
+  auto_save_resume: 'Reprendre',
+  auto_saved_at: 'Enregistré automatiquement $1',
+  auto_saving: 'Enregistrement…',
   browse: 'parcourez',
   bulk_upload_dialog_title: 'Téléchargement groupé',
   cancel: 'Annuler',
@@ -10,12 +19,19 @@ export default {
   create_first: 'Créer votre {premier|première} $1',
   create_new: 'Créer {un|une} $1',
   created_at: 'Création',
+  created_by: 'Créé par',
+  updated_by: 'Modifié par',
   create_folder: 'Nouveau dossier',
   create: 'Créer',
   delete: 'Supprimer $1',
   delete_dialog_title: 'Supprimer $1',
   delete_dialog_text:
     "Vous êtes sur le point de supprimer $1, appuyez sur supprimer pour confirmer l'opération.",
+  delete_document: 'Supprimer le document',
+  delete_version: 'Supprimer cette version',
+  delete_version_dialog_title: 'Supprimer cette version',
+  delete_version_dialog_text:
+    'Vous êtes sur le point de supprimer cette version du document. Les autres versions restent.',
   duplicate: 'Dupliquer',
   duplicate_success: 'Dupliqué avec succès',
   doc_deleted: 'Document supprimé',
@@ -56,14 +72,17 @@ export default {
   select_all: 'Tout sélectionner',
   sendPasswordResetLink: 'Envoyer un lien de réinitialisation',
   signin: 'Se connecter',
+  someone: 'Quelqu’un',
   unsaved_dialog_title: 'Modification(s) non-enregistrée(s)',
   unsaved_dialog_text: 'Il y a des modifications non-enregistrées pour ce document.',
   version_created: 'Nouvelle version créée',
+  version_deleted: 'Version supprimée',
   versions_history: 'Historique des versions',
   versions: 'Versions',
   view_all: 'Voir tout',
   view_page: 'Voir la page',
   view_site: 'Voir le site',
   welcome: 'Bienvenue',
-  confirmPassword: 'Confirmez le mot de passe'
+  confirmPassword: 'Confirmez le mot de passe',
+  your_auto_save: 'Votre enregistrement automatique'
 };

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

@@ -1,6 +1,5 @@
 export declare const languages: readonly ["fr", "en"];
 export declare const namespaces: readonly ["errors", "fields", "common", "mail"];
-export declare const DEFAULT_LOCALE = "en";
 export type PanelLanguage = (typeof languages)[number];
 export type Namespace = (typeof namespaces)[number];
 export type Dictionaries = Record<string, Record<string, string>>;

package/dist/core/i18n/index.js

@@ -1,6 +1,5 @@
 export const languages = ['fr', 'en'];
 export const namespaces = ['errors', 'fields', 'common', 'mail'];
-export const DEFAULT_LOCALE = 'en';
 function createI18n() {
     let dictionaries = {};
     const templateCache = new Map();

package/dist/core/locale/copy.server.d.ts

@@ -0,0 +1,35 @@
+import type { BuiltArea, BuiltCollection } from '../config/types.js';
+import type { GenericDoc } from '../prototype/types.js';
+import type { Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/** A row to read from or write to: a document, and its version row when the config has them. */
+type Row = {
+    id?: string;
+    versionId?: string;
+    latest?: boolean;
+};
+/**
+ * Copies the other locales of one row onto another, as `duplicate` does for a copy and
+ * `handleNewVersion` for a new version.
+ *
+ * Each locale is read raw off the source — the locale's own rows, no fallback — so what a locale
+ * never wrote stays unwritten on the target too, and falls back on read like anywhere else. The
+ * target's unlocalized blocks and tree nodes already exist, written with the locale the target
+ * was created in: their ids are put back on the source's, matched by position and shape, so the
+ * copy updates those rows rather than adding a second set. Localized ones are per locale and are
+ * created fresh. The write is a locale copy: validation and field hooks ran where the values came
+ * from and stand down here, so a required field a locale never filled stays empty on the copy.
+ */
+export declare const copyLocales: (args: {
+    event: RequestEvent;
+    config: BuiltCollection | BuiltArea;
+    source: Row;
+    /** `doc` is the target as written in the locale it was created in — where the ids come from. */
+    target: Row & {
+        doc: GenericDoc;
+    };
+    locales: string[];
+    /** A last touch on each locale's data before it is written — a copy's title, say. */
+    prepare?: (data: Dic, locale: string) => Dic;
+}) => Promise<void>;
+export {};

package/dist/core/locale/copy.server.js

@@ -0,0 +1,93 @@
+import { buildConfigMap } from '../pipeline/config-map/index.js';
+import { BlocksBuilder } from '../../fields/blocks/index.js';
+import { TreeBuilder } from '../../fields/tree/index.js';
+import { getValueAtPath, isObjectLiteral, matchStructure, omitId, setValueAtPath } from '../../util/object.js';
+/**
+ * Copies the other locales of one row onto another, as `duplicate` does for a copy and
+ * `handleNewVersion` for a new version.
+ *
+ * Each locale is read raw off the source — the locale's own rows, no fallback — so what a locale
+ * never wrote stays unwritten on the target too, and falls back on read like anywhere else. The
+ * target's unlocalized blocks and tree nodes already exist, written with the locale the target
+ * was created in: their ids are put back on the source's, matched by position and shape, so the
+ * copy updates those rows rather than adding a second set. Localized ones are per locale and are
+ * created fresh. The write is a locale copy: validation and field hooks ran where the values came
+ * from and stand down here, so a required field a locale never filled stays empty on the copy.
+ */
+export const copyLocales = async (args) => {
+    const { event, config, source, target, locales, prepare } = args;
+    const { rime } = event.locals;
+    const current = rime.getLocale();
+    for (const locale of locales) {
+        rime.setLocale(locale);
+        let data = config.type === 'collection'
+            ? await rime.collection(config.slug).findById({
+                id: source.id,
+                locale,
+                versionId: source.versionId,
+                latest: source.latest,
+                localeFallback: false
+            })
+            : await rime.area(config.slug).find({
+                locale,
+                versionId: source.versionId,
+                latest: source.latest,
+                localeFallback: false
+            });
+        const configMap = buildConfigMap(data, config.fields);
+        // Nothing localized in it: the source never wrote this locale, and neither does the copy.
+        const written = Object.entries(configMap).some(([key, field]) => field.get.localized && !field.use.isEmpty(getValueAtPath(key, data)));
+        if (!written)
+            continue;
+        for (const [key, field] of Object.entries(configMap)) {
+            if (!(field instanceof BlocksBuilder) && !(field instanceof TreeBuilder))
+                continue;
+            if (field.get.localized) {
+                const value = (getValueAtPath(key, data) ?? []).map((block) => omitId(block));
+                data = setValueAtPath(key, data, value);
+                continue;
+            }
+            const sameType = (a, b) => field.type === 'tree' || a.type === b.type;
+            const targetBlocks = getValueAtPath(key, target.doc) ?? [];
+            targetBlocks.forEach((block, index) => {
+                const sourceBlock = getValueAtPath(`${key}.${index}`, data);
+                const match = sourceBlock &&
+                    sourceBlock.id &&
+                    matchStructure(block, sourceBlock) &&
+                    sameType(sourceBlock, block);
+                data = match ? setValueAtPath(`${key}.${index}.id`, data, block.id) : data;
+            });
+        }
+        data = withoutRowMetas(data);
+        delete data.id;
+        delete data.status;
+        if (prepare)
+            data = prepare(data, locale);
+        if (config.type === 'collection') {
+            await rime.collection(config.slug).updateById({
+                id: target.id,
+                versionId: target.versionId,
+                data,
+                locale,
+                isLocaleCopy: true
+            });
+        }
+        else {
+            await rime
+                .area(config.slug)
+                .update({ versionId: target.versionId, data, locale, isLocaleCopy: true });
+        }
+    }
+    rime.setLocale(current);
+};
+/** What a row owns and a copy of it does not: who wrote it, when, and for whom. Ids stay. */
+const withoutRowMetas = (value) => {
+    if (Array.isArray(value))
+        return value.map(withoutRowMetas);
+    if (!isObjectLiteral(value))
+        return value;
+    const metas = ['ownerId', 'createdAt', 'updatedAt', 'createdBy', 'updatedBy'];
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => !metas.includes(key))
+        .map(([key, nested]) => [key, withoutRowMetas(nested)]));
+};

package/dist/core/locale/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Which languages a config speaks.
+ *
+ * `core/locale/` because locale is one of the four things core and the adapter may name — the
+ * adapter says `locale` 18 times in the contract — and it extends no prototype.
+ */
+export type LocalizationConfig = {
+    locales: LocaleConfig[];
+    default: string;
+    /**
+     * Whether a read fills what a locale has not written yet from the other locales — the
+     * requested locale, then the default, then the rest in config order, field by field. `true`
+     * unless said otherwise; `false` reads one locale only, untranslated fields empty.
+     */
+    fallback?: boolean;
+};
+export type LocaleConfig = {
+    code: string;
+    label: string;
+};