@rebasepro/app 0.13.0 → 0.13.1-canary.g18cfeb7

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