@rebasepro/app 0.13.0 → 0.13.1-canary.g249daa1

package/src/hooks/useBuildLocalConfigurationPersistence.tsx

@@ -1,15 +1,16 @@
 import { useCallback, useEffect, useRef, useState, useMemo } from "react";
 import { PartialCollectionConfig, UserConfigurationPersistence } from "@rebasepro/admin-types";
 import { stripCollectionPath } from "@rebasepro/common";
-import { mergeDeep } from "@rebasepro/utils";
+import { isArrayValue, isRecordValue, mergeDeep, readStoredJson, writeStoredJson } from "@rebasepro/utils";
 
 export function useBuildLocalConfigurationPersistence(): UserConfigurationPersistence {
 
     const configCache = useRef<Record<string, PartialCollectionConfig>>({});
 
-    const getCollectionFromStorage = useCallback((storageKey: string) => {
-        const item = localStorage.getItem(storageKey);
-        return item ? JSON.parse(item) : {};
+    // Read during render by every collection view, so an unreadable value here
+    // used to throw the view away rather than fall back to an unconfigured one.
+    const getCollectionFromStorage = useCallback(<M extends Record<string, any>>(storageKey: string): PartialCollectionConfig<M> => {
+        return readStoredJson<PartialCollectionConfig<M>>(storageKey, { fallback: {}, accept: isRecordValue });
     }, []);
 
     const getCollectionConfig = useCallback(<M extends Record<string, any>>(path: string): PartialCollectionConfig<M> => {
@@ -22,9 +23,15 @@ export function useBuildLocalConfigurationPersistence(): UserConfigurationPersis
 
     const onCollectionModified = useCallback(<M extends Record<string, any>>(path: string, data: PartialCollectionConfig<M>) => {
         const storageKey = `collection_config::${stripCollectionPath(path)}`;
-        localStorage.setItem(storageKey, JSON.stringify(data));
+        writeStoredJson(storageKey, data);
         const cachedConfig = configCache.current[storageKey];
-        const newConfig = mergeDeep(cachedConfig ?? getCollectionFromStorage(path), data);
+        // `getCollectionFromStorage` takes the storage key, not the path — every
+        // other caller passes one. Reading `path` looked up a key this hook
+        // never writes, so the fallback could only ever contribute `{}`. It is
+        // masked today because the one caller merges the stored config in
+        // before calling, but `onCollectionModified` accepts a partial by type
+        // and by its public interface, and a real partial would lose the rest.
+        const newConfig = mergeDeep(cachedConfig ?? getCollectionFromStorage(storageKey), data);
         configCache.current[storageKey] = mergeDeep(configCache.current[storageKey], newConfig);
     }, [getCollectionFromStorage]);
 
@@ -33,23 +40,24 @@ export function useBuildLocalConfigurationPersistence(): UserConfigurationPersis
     const [collapsedGroups, _setCollapsedGroups] = useState<string[]>([]);
 
     useEffect(() => {
-        _setRecentlyVisitedPaths(localStorage.getItem("recently_visited_paths") ? JSON.parse(localStorage.getItem("recently_visited_paths")!) : []);
-        _setFavouritePaths(localStorage.getItem("favourite_paths") ? JSON.parse(localStorage.getItem("favourite_paths")!) : []);
-        _setCollapsedGroups(localStorage.getItem("collapsed_groups") ? JSON.parse(localStorage.getItem("collapsed_groups")!) : []);
+        const readPaths = (key: string) => readStoredJson<string[]>(key, { fallback: [], accept: isArrayValue });
+        _setRecentlyVisitedPaths(readPaths("recently_visited_paths"));
+        _setFavouritePaths(readPaths("favourite_paths"));
+        _setCollapsedGroups(readPaths("collapsed_groups"));
     }, []);
 
     const setRecentlyVisitedPaths = useCallback((paths: string[]) => {
-        localStorage.setItem("recently_visited_paths", JSON.stringify(paths));
+        writeStoredJson("recently_visited_paths", paths);
         _setRecentlyVisitedPaths(paths);
     }, []);
 
     const setFavouritePaths = useCallback((paths: string[]) => {
-        localStorage.setItem("favourite_paths", JSON.stringify(paths));
+        writeStoredJson("favourite_paths", paths);
         _setFavouritePaths(paths);
     }, []);
 
     const setCollapsedGroups = useCallback((paths: string[]) => {
-        localStorage.setItem("collapsed_groups", JSON.stringify(paths));
+        writeStoredJson("collapsed_groups", paths);
         _setCollapsedGroups(paths);
     }, []);
 

package/src/locales/de.ts

@@ -77,6 +77,7 @@ export const de: RebaseTranslations = {
     column_cannot_be_edited: "Diese Spalte kann nicht direkt bearbeitet werden",
     close: "Schließen",
     hide_list: "Liste ausblenden",
+    show_list: "Liste einblenden",
     unsaved_local_changes: "Ungespeicherte lokale Änderungen",
     unsaved_local_changes_description: "Dieses Dokument wurde lokal bearbeitet und weist ungespeicherte Änderungen auf. Diese lokalen Änderungen gehen verloren, wenn Sie sie nicht anwenden.",
     preview_changes: "Änderungen in der Vorschau anzeigen",

package/src/locales/en.ts

@@ -87,6 +87,7 @@ export const en: RebaseTranslations = {
     column_cannot_be_edited: "This column can't be edited directly",
     close: "Close",
     hide_list: "Hide list",
+    show_list: "Show list",
     unsaved_local_changes: "Unsaved Local changes",
     unsaved_local_changes_description: "This document was edited locally and has unsaved changes. These local changes will be lost if you don't apply them.",
     preview_changes: "Preview Changes",
@@ -993,6 +994,7 @@ export const en: RebaseTranslations = {
     inspect_record: "Inspect record",
     inspect: "Inspect",
     close_inspector: "Close inspector",
+    open_in_live_site: "Open in the live site",
 
     // ─── Revision history ───────────────────────────────────────
     history_revert: "Revert to this version",

package/src/locales/es.ts

@@ -85,6 +85,7 @@ export const es: RebaseTranslations = {
     column_cannot_be_edited: "Esta columna no se puede editar directamente",
     close: "Cerrar",
     hide_list: "Ocultar lista",
+    show_list: "Mostrar lista",
     unsaved_local_changes: "Cambios locales sin guardar",
     unsaved_local_changes_description: "Este documento ha sido editado localmente y tiene cambios sin guardar. Estos cambios locales se perderán si no los aplicas.",
     preview_changes: "Previsualizar cambios",

package/src/locales/fr.ts

@@ -77,6 +77,7 @@ export const fr: RebaseTranslations = {
     column_cannot_be_edited: "Cette colonne ne peut pas être modifiée directement",
     close: "Fermer",
     hide_list: "Masquer la liste",
+    show_list: "Afficher la liste",
     unsaved_local_changes: "Modifications locales non enregistrées",
     unsaved_local_changes_description: "Ce document a été modifié localement et contient des modifications non enregistrées. Ces modifications locales seront perdues si vous ne les appliquez pas.",
     preview_changes: "Aperçu des modifications",

package/src/locales/hi.ts

@@ -69,7 +69,7 @@ export const hi: RebaseTranslations = {
     group_by: "इसके द्वारा समूहित करें",
     initialize_kanban_order: "कानबन क्रम प्रारंभ करें",
     copy_id: "ID कॉपी करें",
-    add_specific: "विशिष्ट {{name}} जोड़ें",
+    add_specific: "{{name}} जोड़ें",
     select_specific: "विशिष्ट {{name}} चुनें",
     select_from: "{{name}} से चुनें",
     done: "हो गया",
@@ -77,6 +77,7 @@ export const hi: RebaseTranslations = {
     column_cannot_be_edited: "इस कॉलम को सीधे संपादित नहीं किया जा सकता",
     close: "बंद करें",
     hide_list: "सूची छिपाएँ",
+    show_list: "सूची दिखाएँ",
     unsaved_local_changes: "सहेजे नहीं गए स्थानीय परिवर्तन",
     unsaved_local_changes_description: "इस दस्तावेज़ को स्थानीय स्तर पर संपादित किया गया था और इसमें सहेजे नहीं गए परिवर्तन हैं। यदि आप इन्हें लागू नहीं करते हैं तो ये स्थानीय परिवर्तन खो जाएंगे।",
     preview_changes: "परिवर्तनों का पूर्वावलोकन करें",

package/src/locales/it.ts

@@ -77,6 +77,7 @@ export const it: RebaseTranslations = {
     column_cannot_be_edited: "Questa colonna non può essere modificata direttamente",
     close: "Chiudi",
     hide_list: "Nascondi elenco",
+    show_list: "Mostra elenco",
     unsaved_local_changes: "Modifiche locali non salvate",
     unsaved_local_changes_description: "Questo documento è stato modificato localmente e ha modifiche non salvate. Queste modifiche locali andranno perse se non le applichi.",
     preview_changes: "Anteprima modifiche",

package/src/locales/pt.ts

@@ -82,6 +82,7 @@ export const pt: RebaseTranslations = {
     column_cannot_be_edited: "Esta coluna não pode ser editada diretamente",
     close: "Fechar",
     hide_list: "Ocultar lista",
+    show_list: "Mostrar lista",
     unsaved_local_changes: "Alterações locais não guardadas",
     unsaved_local_changes_description: "Este documento foi editado localmente e tem alterações não guardadas. Estas alterações locais serão perdidas se não as aplicar.",
     preview_changes: "Pré-visualizar alterações",

package/src/util/entity_cache.ts

@@ -4,7 +4,21 @@ import { isObject, isPlainObject } from "@rebasepro/utils";
 // Define a unique prefix for entity keys in sessionStorage to avoid key collisions
 const LOCAL_STORAGE_PREFIX = "entity_cache::";
 
-// In-memory cache to store entities for quick access
+/**
+ * The in-session handoff channel: an edit in flight, parked here by the layout
+ * that is being replaced and picked up by the one taking over — the split's
+ * "hide list", full screen's "show list", the side panel's "open full screen".
+ * A record loaded from it opens *dirty*, because that is what it is for.
+ *
+ * Deliberately **not** hydrated from `sessionStorage`, and it is the one thing
+ * here that isn't. The persisted half of this file is the local-changes backup:
+ * a draft that outlives a reload, offered back through the banner or applied on
+ * open, according to the collection's `localChangesBackup`. Loading those
+ * drafts into this map on startup made every one of them look like a handoff —
+ * the first visit to the record after a reload silently opened dirty carrying a
+ * draft the user had walked away from, and the banner that exists to ask about
+ * it never appeared.
+ */
 const entityCache: Map<string, object> = new Map();
 
 // Check `sessionStorage` availability once during initialization
@@ -93,35 +107,12 @@ function customReviver(_key: string, value: unknown): unknown {
     return value;
 }
 
-// Initialize the in-memory cache by loading entities from `sessionStorage`
-if (isSessionStorageAvailable) {
-    try {
-        // Iterate over all keys in sessionStorage to find those with the specified prefix
-        for (let i = 0; i < sessionStorage.length; i++) {
-            const fullKey = sessionStorage.key(i);
-            if (fullKey && fullKey.startsWith(LOCAL_STORAGE_PREFIX)) {
-                const path = fullKey.substring(LOCAL_STORAGE_PREFIX.length);
-                const entityString = sessionStorage.getItem(fullKey);
-                if (entityString) {
-                    try {
-                        const entity: object = JSON.parse(entityString, customReviver);
-                        entityCache.set(path, entity);
-                    } catch (parseError) {
-                        console.error(
-                            `Failed to parse entity for path "${path}" from sessionStorage:`,
-                            parseError
-                        );
-                    }
-                }
-            }
-        }
-    } catch (error) {
-        console.error("Error accessing sessionStorage during initialization:", error);
-    }
-}
-
 /**
- * Saves data to the in-memory cache and persists it individually in `sessionStorage`.
+ * Saves data to the local-changes backup in `sessionStorage`.
+ *
+ * The backup only — a draft that survives a reload is not an edit in flight.
+ * {@link saveEntityToMemoryCache} is the other channel; see {@link entityCache}
+ * for what separates them.
  * @param path - The unique path/key for the data.
  * @param data - The data to cache and persist.
  */
@@ -142,10 +133,19 @@ export function saveEntityToCache(path: string, data: object): void {
     }
 }
 
+/**
+ * Consumes a handoff. The channel is one-shot: whoever picks an edit up owns it
+ * from then on, and an edit left behind here is one that reopens a record dirty
+ * long after the user stopped looking at it.
+ */
 export function removeEntityFromMemoryCache(path: string): void {
     entityCache.delete(path);
 }
 
+/**
+ * Parks an edit in flight for the layout about to take over. See
+ * {@link entityCache}: this is the handoff, not the backup.
+ */
 export function saveEntityToMemoryCache(path: string, data: object): void {
     entityCache.set(path, data);
 }
@@ -156,8 +156,11 @@ export function getEntityFromMemoryCache(path: string): object | undefined {
 
 
 /**
- * Retrieves a entity from the in-memory cache or `sessionStorage`.
- * If the entity is not in the cache but exists in `sessionStorage`, it loads it into the cache.
+ * Retrieves a entity from the local-changes backup in `sessionStorage`.
+ *
+ * The backup only — the handoff channel is read through
+ * {@link getEntityFromMemoryCache}, and the two mean different things to the
+ * form that receives them.
  * @param path - The unique path/key for the entity.
  * @returns The cached entity or `undefined` if not found.
  */

package/src/util/previews.ts

@@ -3,6 +3,7 @@ import type { PropertyConfig, AdminCollection } from "@rebasepro/admin-types";
 import { AuthController } from "@rebasepro/admin-types";
 import { isPropertyBuilder } from "@rebasepro/common";
 import { getTitlePropertyKey } from "@rebasepro/app";
+import { SUMMARY_RANK, isStorageProperty, rankSummaryProperty } from "../collections/summary-property";
 
 function isReferenceProperty(property: Property) {
     if (!property) return null;
@@ -30,24 +31,24 @@ function isHiddenProperty(property: Property | undefined): boolean {
 }
 
 /**
- * Returns true when the property holds file-storage content (single image,
- * array of images, generic upload, …).  These properties are rendered by the
- * dedicated image-slot and should NOT appear as regular preview columns.
+ * The properties a preview surface should render for a record, best first.
+ *
+ * Three things decide the answer, in this order:
+ *
+ * 1. `previewProperties` — passed in, or declared on the collection. A stated
+ *    list is returned verbatim, ranking and limit included: a developer who
+ *    asks for the Markdown biography gets the Markdown biography.
+ * 2. Whether the value has a one-line form at all. A map renders as a
+ *    key/value table and a Markdown field as a document; neither fits a card
+ *    line, so they never take a slot from a value that does. See
+ *    {@link rankSummaryProperty}.
+ * 3. `propertiesOrder`, which breaks ties.
+ *
+ * The middle step is the one that is easy to get wrong by leaving out.
+ * `propertiesOrder` states the *column* order of a collection table — it is
+ * not a statement that the first three columns summarise a record, and reading
+ * it as one is how a card ends up rendering somebody's entire biography.
  */
-function isStorageProperty(property: Property | undefined): boolean {
-    if (!property) return false;
-    // Single string with storage config
-    if (property.type === "string" && property.storage) return true;
-    // String displayed as image URL
-    if (property.type === "string" && property.admin?.urlPreview === "image") return true;
-    // Array whose inner element has storage config or image URL
-    if (property.type === "array" && property.of && !Array.isArray(property.of)) {
-        const inner = property.of;
-        if (inner.type === "string" && (inner.storage || inner.admin?.urlPreview === "image")) return true;
-    }
-    return false;
-}
-
 export function getEntityPreviewKeys(
     authController: AuthController,
     targetCollection: AdminCollection<any>,
@@ -61,19 +62,38 @@ export function getEntityPreviewKeys(
     }
     if (listProperties && listProperties.length > 0) {
         return listProperties;
-    } else {
-        listProperties = (targetCollection.propertiesOrder as string[]) || allProperties;
-        return listProperties
-            .filter(key => {
-                const prop = targetCollection.properties[key];
-                const isIdProp = prop && typeof prop === "object" && "isId" in prop && Boolean((prop as { isId?: boolean }).isId);
-                return !isIdProp && key !== "id";
-            })
-            .filter(key => {
-                const property = targetCollection.properties[key];
-                return property && !isPropertyBuilder(property) && !isReferenceProperty(property) && !isRelationProperty(property) && !isHiddenProperty(property) && !isStorageProperty(property as Property);
-            }).slice(0, limit);
     }
+
+    // Relations read as a link to somewhere else rather than as a value here,
+    // so they are left to the dedicated relation chips — unless the collection
+    // ordered its properties explicitly, which puts them back in play.
+    const hasExplicitOrder = !!(targetCollection.propertiesOrder as string[] | undefined);
+    const order = (targetCollection.propertiesOrder as string[]) || allProperties;
+
+    const direct: string[] = [];
+    const excerpt: string[] = [];
+
+    for (const key of order) {
+        const property = targetCollection.properties[key];
+        if (!property || isPropertyBuilder(property)) continue;
+        if (key === "id" || ("isId" in property && Boolean((property as { isId?: boolean }).isId))) continue;
+        if (isReferenceProperty(property)) continue;
+        if (!hasExplicitOrder && isRelationProperty(property)) continue;
+        if (isHiddenProperty(property)) continue;
+        if (isStorageProperty(property as Property)) continue;
+
+        const rank = rankSummaryProperty(property as Property);
+        if (rank === SUMMARY_RANK.UNUSABLE) continue;
+        (rank === SUMMARY_RANK.EXCERPT ? excerpt : direct).push(key);
+
+        // Every remaining slot can already be filled by a value that fits
+        // whole, so nothing below can change the answer.
+        if (direct.length >= limit) break;
+    }
+
+    // A long-text field is a poor summary but a fine last resort: better an
+    // opening line than a card with nothing under the title.
+    return [...direct, ...excerpt].slice(0, limit);
 }
 
 // Returned as-is rather than rebuilt per call, so the result is referentially