@rebasepro/app 0.13.0 → 0.13.1-canary.g06dbe5b

package/src/core/Rebase.tsx

@@ -6,7 +6,7 @@ import type { ComponentOverrideMap } from "@rebasepro/admin-types";
 import React, { useEffect, useMemo, useRef, useState } from "react";
 import { CenteredView, Typography } from "@rebasepro/ui";
 import { User, CollectionRegistryController, DataDriver, DataSourceDefinition, RebaseData, DEFAULT_DATA_SOURCE_KEY, StorageSource, StorageSourceDefinition, DEFAULT_STORAGE_SOURCE_KEY } from "@rebasepro/types";
-import { RebaseContext } from "@rebasepro/admin-types";
+import { RebaseContext, UNRENDERED_SLOTS } from "@rebasepro/admin-types";
 import { PluginProviderStack } from "./PluginProviderStack";
 import { PluginLifecycleManager } from "./PluginLifecycleManager";
 import { AuthControllerContext, CollectionResolverRegistrationContext, CollectionResolver } from "../contexts";
@@ -46,7 +46,7 @@ import { useBuildEffectiveRoleController } from "../hooks/useBuildEffectiveRoleC
  *
  * @group Core
  */
-export function Rebase<USER extends User>(props: RebaseProps<USER>) {
+export function Rebase<USER extends User, DB = unknown>(props: RebaseProps<USER, DB>) {
 
     const {
         children,
@@ -90,6 +90,24 @@ export function Rebase<USER extends User>(props: RebaseProps<USER>) {
         ...((plugins ?? []).flatMap((p) => p.slots ?? []))
     ], [directSlots, plugins]);
 
+    // Seven of the twenty-nine declared slots are rendered nowhere. They have
+    // props interfaces and rows in the public slot reference, so registering
+    // for one looks exactly like registering for one that works — and then
+    // nothing happens, with no way to tell whether the fault is the plugin's.
+    // `UNRENDERED_SLOTS` is kept honest by `slot-render-sites.test.ts`, which
+    // derives the same set by scanning for render sites.
+    useEffect(() => {
+        const dead = new Set<string>(UNRENDERED_SLOTS);
+        const registered = new Set(resolvedSlots.map(s => s.slot).filter(slot => dead.has(slot)));
+        for (const slot of registered) {
+            console.warn(
+                `[Rebase] A component is registered for the "${slot}" slot, which this ` +
+                "build declares but renders nowhere — nothing will appear. This is a gap " +
+                "in Rebase, not in your plugin."
+            );
+        }
+    }, [resolvedSlots]);
+
 
     // Auth fallback logic
     const clientAuthController = useAuthSubscription(authControllerProp ? undefined : client?.auth);

package/src/core/RebaseProps.tsx

@@ -105,7 +105,7 @@ import type { EffectiveRoleController } from "@rebasepro/types";
  *
  * @group Models
  */
-export type RebaseProps<USER extends User> = {
+export type RebaseProps<USER extends User, DB = unknown> = {
 
     /**
      * The root components of your application. Use RebaseAdmin, RebaseStudio, and RebaseShell.
@@ -151,8 +151,16 @@ export type RebaseProps<USER extends User> = {
      * entry keyed `"(default)"` carries a driver.
      * `client.auth` is subscribed unless `authController` is provided.
      * `client.storage` is used unless `storageSource` is provided.
+     *
+     * `DB` is inferred from whatever is passed, and defaults to `unknown` for
+     * an untyped client. It has to be a parameter rather than a fixed
+     * `RebaseClient`: `RebaseClient<unknown>` is not a supertype of
+     * `RebaseClient<Database>` — the dynamic branch of `RebaseSdkData` is an
+     * index signature that no concrete instantiation satisfies — so pinning it
+     * here rejected the client of every project that generates a `Database`
+     * type, which is the whole typed-SDK path.
      */
-    client?: RebaseClient;
+    client?: RebaseClient<DB>;
 
     /**
      * The data sources of the app. Each entry pairs a

package/src/hooks/data/collectionQuery.ts

@@ -0,0 +1,55 @@
+import type { FindParams, FilterValues, LogicalCondition } from "@rebasepro/types";
+
+/**
+ * The one place a collection read's parameters are assembled.
+ *
+ * ## Why this exists
+ *
+ * Four call sites used to build this object by hand — `useCollection` and
+ * `useDataTableController`, each in both their `listen` and `find` branches.
+ * Every one of them listed the fields it forwarded, so adding an option to
+ * `FindParams` meant remembering four places, and forgetting one failed
+ * silently: the option simply never reached the server, and the feature it
+ * enabled looked broken for reasons nowhere near the code that dropped it.
+ *
+ * That is not hypothetical. `searchExplain` was added to three of the four and
+ * the miss was found by intercepting a WebSocket frame, because nothing else
+ * could see it.
+ *
+ * A field added here reaches every read. `toFindParams` returns `FindParams`
+ * itself, so the compiler checks the shape rather than a hand-copied list.
+ */
+export interface CollectionQueryInput<M extends Record<string, unknown>> {
+    where?: FilterValues<Extract<keyof M, string>>;
+    logical?: LogicalCondition;
+    /**
+     * Loosened from `FindParams["orderBy"]` on purpose: callers hold the sort
+     * as a plain `[string, direction]` read off user config or a URL, where the
+     * column is not statically known. Narrowing it here would push a cast onto
+     * every call site, which is the kind of friction that sends people back to
+     * hand-building the object this exists to replace.
+     */
+    orderBy?: [string, "asc" | "desc"];
+    limit?: number;
+    offset?: number;
+    page?: number;
+    searchString?: string;
+    include?: string[];
+}
+
+/**
+ * Build the parameters for one collection read.
+ *
+ * Derived options live here rather than at the call sites, so they cannot
+ * disagree: `searchExplain` rides along exactly when there is a search string
+ * to explain, which is also the only time it costs anything.
+ */
+export function toFindParams<M extends Record<string, unknown>>(
+    input: CollectionQueryInput<M>
+): FindParams<M> {
+    const { searchString, ...rest } = input;
+    return {
+        ...rest,
+        ...(searchString ? { searchString, searchExplain: true } : {})
+    } as FindParams<M>;
+}

package/src/hooks/data/useCollection.tsx

@@ -3,6 +3,7 @@ import { useEffect, useState, useMemo } from "react";
 import { Entity, FilterValues, User } from "@rebasepro/types";
 import { useData } from "./useData";
 import { isSchemaDriftError, useSchemaDriftContext } from "../../components/SchemaDriftBanner";
+import { toFindParams } from "./collectionQuery";
 import { getRelationIncludeParams } from "../../util/previews";
 import type { AdminCollection } from "@rebasepro/admin-types";
 /**
@@ -136,30 +137,37 @@ export function useCollection<M extends Record<string, any>, USER extends User>(
         const includeParams = getRelationIncludeParams(collection);
 
         if (accessor.listen) {
-            return accessor.listen({
-                where: whereParams,
-                limit: itemCount,
-                offset,
-                page,
-                orderBy: orderByParams,
-                searchString,
-                include: includeParams
-            }, (res) => onEntitiesUpdate({ data: res.data as Entity<M>[],
+            // Assembled in one place — see `toFindParams`.
+            return accessor.listen(
+                toFindParams({ where: whereParams, limit: itemCount, offset, page,
+                    orderBy: orderByParams, searchString, include: includeParams }),
+                (res) => onEntitiesUpdate({ data: res.data as Entity<M>[],
 meta: res.meta }), onError);
         } else {
-            accessor.find({
-                where: whereParams,
-                limit: itemCount,
-                offset,
-                page,
-                orderBy: orderByParams,
-                searchString,
-                include: includeParams
-            })
-                .then((res) => onEntitiesUpdate({ data: res.data as Entity<M>[],
-meta: res.meta }))
-                .catch(onError);
+            // The one-shot fallback, taken whenever the client has no socket.
+            // `listen` above cancels on cleanup, and every dependency of this
+            // effect — the search string, the filters, the sort, the page —
+            // changes while a request is in flight. A promise cannot be
+            // unsubscribed, so the cleanup has to disown its result instead:
+            // without this, whichever response arrives last wins, and responses
+            // do not arrive in request order. Typing into search would settle
+            // on the results for whichever query the server happened to finish
+            // last.
+            let cancelled = false;
+            accessor.find(
+                toFindParams({ where: whereParams, limit: itemCount, offset, page,
+                    orderBy: orderByParams, searchString, include: includeParams }))
+                .then((res) => {
+                    if (cancelled) return;
+                    onEntitiesUpdate({ data: res.data as Entity<M>[],
+meta: res.meta });
+                })
+                .catch((e) => {
+                    if (cancelled) return;
+                    onError(e);
+                });
             return () => {
+                cancelled = true;
             };
         }
     }, [path, itemCount, offset, page, currentSort, sortByProperty, filterValues, searchString, dataClient, collection]);

package/src/hooks/data/useFetch.tsx

@@ -117,10 +117,25 @@ export function useFetch<M extends Record<string, any>, USER extends User = User
             if (accessor.listenById) {
                 return accessor.listenById(entityId, (entity) => onEntityUpdate(entity as Entity<M> | undefined), onError);
             } else {
+                // The one-shot fallback, taken whenever the client has no
+                // socket. `listenById` above cancels on cleanup; a promise
+                // cannot, so the cleanup disowns its result instead. `entityId`
+                // is an effect dependency, and where this hook's caller is not
+                // remounted per record — the side panel replaces its contents
+                // in place — a slow response for the record just left would
+                // otherwise land on top of the one now showing.
+                let cancelled = false;
                 accessor.findById(entityId)
-                    .then((entity) => onEntityUpdate(entity as Entity<M> | undefined))
-                    .catch(onError);
+                    .then((entity) => {
+                        if (cancelled) return;
+                        onEntityUpdate(entity as Entity<M> | undefined);
+                    })
+                    .catch((e) => {
+                        if (cancelled) return;
+                        onError(e);
+                    });
                 return () => {
+                    cancelled = true;
                 };
             }
         }

package/src/hooks/data/useRelationSelector.tsx

@@ -41,6 +41,17 @@ export interface UseRelationSelectorProps<M extends Record<string, any> = any> {
      * Property name to use as the secondary display field
      */
     descriptionProperty?: keyof M;
+    /**
+     * Whether the list should be fetched at all. Defaults to `true`.
+     *
+     * A picker that is mounted is not a picker that is open, and the two used
+     * to be the same thing here: the fetch ran on mount, so a collection table
+     * with a relation column paid for one query — or one realtime subscription
+     * — per rendered row before anyone clicked a cell. Pass `false` until the
+     * list is actually needed and nothing is requested; flipping it to `true`
+     * fetches once, and it never goes back.
+     */
+    enabled?: boolean;
 }
 
 export interface RelationSelectorController {
@@ -66,7 +77,8 @@ export function useRelationSelector<M extends Record<string, any> = any>(
         pageSize = DEFAULT_PAGE_SIZE,
         getLabelFromEntity,
         getDescriptionFromEntity,
-        descriptionProperty
+        descriptionProperty,
+        enabled = true
     }: UseRelationSelectorProps<M>
 ): RelationSelectorController {
 
@@ -82,6 +94,10 @@ export function useRelationSelector<M extends Record<string, any> = any>(
 
     const unsubscribeRef = useRef<(() => void) | null>(null);
     const searchTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+    // Whether a fetch has ever completed. Between `enabled` flipping and the
+    // effect running there is one paint with no items and no request in
+    // flight; without this the list shows "no results" for that frame.
+    const hasLoadedRef = useRef(false);
 
     const setLoading = useCallback((loading: boolean) => {
         isLoadingRef.current = loading;
@@ -149,6 +165,7 @@ export function useRelationSelector<M extends Record<string, any> = any>(
 
         const onEntitiesUpdate = (res: { data: Entity<M>[], meta: { hasMore: boolean } }) => {
             const newItems = res.data.map((e) => entityToRelationItem(e));
+            hasLoadedRef.current = true;
             setItems(newItems);
             setHasMore(res.meta.hasMore);
             setLoading(false);
@@ -156,6 +173,7 @@ export function useRelationSelector<M extends Record<string, any> = any>(
 
         const onErrorUpdate = (fetchError: Error) => {
             console.error("useRelationSelector: Error fetching data:", fetchError);
+            hasLoadedRef.current = true;
             setError(fetchError);
             setLoading(false);
         };
@@ -174,6 +192,14 @@ export function useRelationSelector<M extends Record<string, any> = any>(
             }, (res) => onEntitiesUpdate({ data: res.data as Entity<M>[],
 meta: res.meta }), onErrorUpdate);
         } else {
+            // The one-shot fallback, taken whenever the client has no socket.
+            // `cleanupSubscription` is what keeps this hook's results matching
+            // the query that asked for them, and it can only do that if the
+            // fallback hands back something that actually cancels. A promise
+            // cannot be unsubscribed, so this disowns its result instead —
+            // otherwise the debounce is the only thing between a slow response
+            // for "ab" and its landing on top of the results for "abc".
+            let cancelled = false;
             accessor.find({
                 where: whereParams,
                 limit: limit,
@@ -182,10 +208,18 @@ meta: res.meta }), onErrorUpdate);
                 searchString: currentSearch,
                 include: includeParams
             })
-                .then((res) => onEntitiesUpdate({ data: res.data as Entity<M>[],
-meta: res.meta }))
-                .catch(onErrorUpdate);
-            unsubscribe = () => {};
+                .then((res) => {
+                    if (cancelled) return;
+                    onEntitiesUpdate({ data: res.data as Entity<M>[],
+meta: res.meta });
+                })
+                .catch((e) => {
+                    if (cancelled) return;
+                    onErrorUpdate(e);
+                });
+            unsubscribe = () => {
+                cancelled = true;
+            };
         }
 
         unsubscribeRef.current = unsubscribe || null;
@@ -215,12 +249,13 @@ meta: res.meta }))
 
     // Load initial data and update upon changes
     useEffect(() => {
+        if (!enabled) return;
         fetchData();
 
         return () => {
             cleanupSubscription();
         };
-    }, [fetchData]);
+    }, [fetchData, enabled, cleanupSubscription]);
 
     useEffect(() => {
         return () => {
@@ -232,11 +267,14 @@ meta: res.meta }))
 
     return useMemo(() => ({
         items,
-        isLoading,
+        // Enabled but not answered yet still counts as loading, so the frame
+        // between opening the picker and the request starting shows a spinner
+        // rather than "no results".
+        isLoading: isLoading || (enabled && !hasLoadedRef.current),
         error,
         search,
         loadMore,
         hasMore,
         entityToRelationItem
-    }), [items, isLoading, error, search, loadMore, hasMore, entityToRelationItem]);
+    }), [items, isLoading, error, search, loadMore, hasMore, entityToRelationItem, enabled]);
 }

package/src/hooks/useAuthSubscription.ts

@@ -50,9 +50,25 @@ export function useAuthSubscription(authClient?: AuthClient): AuthController {
                     if (user) {
                         setUser(user);
                     }
+                    setAuthError(undefined);
                 })
-                .catch(e => {
-                    // Ignore, user just isn't logged in
+                .catch((e: unknown) => {
+                    // A 401 or 403 is the ordinary first load of an anonymous
+                    // visitor: there is no session, which is not an error.
+                    //
+                    // Everything else is. This used to swallow the lot with
+                    // "Ignore, user just isn't logged in", leaving `authError`
+                    // — a field this controller declares and `Rebase` renders a
+                    // full-screen "Error loading auth" view for — permanently
+                    // undefined. So the view was unreachable, and a backend that
+                    // was down, misconfigured, or blocked by CORS looked exactly
+                    // like being signed out: the app showed the login form.
+                    const status = (e as { status?: number } | undefined)?.status;
+                    if (status === 401 || status === 403) {
+                        setAuthError(undefined);
+                        return;
+                    }
+                    setAuthError(e instanceof Error ? e : new Error(String(e)));
                 })
                 .finally(() => {
                     setInitialLoading(false);

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",
@@ -412,6 +413,7 @@ export const de: RebaseTranslations = {
     flatten_arrays: "Arrays glätten",
     download: "Herunterladen",
     large_number_of_documents: "Diese Sammlung hat eine große Anzahl von Dokumenten ({{count}}).",
+    too_many_documents_to_export: "Diese Sammlung enthält mehr Dokumente ({{count}}), als der Browser in einer einzigen Datei exportieren kann (Grenze {{limit}}). Filtern Sie sie vor dem Export.",
     include_undefined_values: "Undefinierte Werte einschließen",
     submit: "Einreichen",
 

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",
@@ -425,6 +426,7 @@ export const en: RebaseTranslations = {
     flatten_arrays: "Flatten arrays",
     download: "Download",
     large_number_of_documents: "This collection has a large number of documents ({{count}}).",
+    too_many_documents_to_export: "This collection has more documents ({{count}}) than the browser can export in a single file (limit {{limit}}). Filter it down before exporting.",
     include_undefined_values: "Include undefined values",
     submit: "Submit",
 
@@ -993,6 +995,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",
@@ -420,6 +421,7 @@ export const es: RebaseTranslations = {
     flatten_arrays: "Aplanar arrays",
     download: "Descargar",
     large_number_of_documents: "Esta colección posee un gran número de documentos ({{count}}).",
+    too_many_documents_to_export: "Esta colección tiene más documentos ({{count}}) de los que el navegador puede exportar en un solo archivo (límite {{limit}}). Fíltrala antes de exportar.",
     include_undefined_values: "Incluir valores omitidos (undefined)",
     submit: "Enviar",
 

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",
@@ -412,6 +413,7 @@ export const fr: RebaseTranslations = {
     flatten_arrays: "Aplatir les tableaux",
     download: "Télécharger",
     large_number_of_documents: "Cette collection contient un grand nombre de documents ({{count}}).",
+    too_many_documents_to_export: "Cette collection contient plus de documents ({{count}}) que le navigateur ne peut en exporter dans un seul fichier (limite {{limit}}). Filtrez-la avant d'exporter.",
     include_undefined_values: "Inclure les valeurs non définies",
     submit: "Soumettre",
 

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: "परिवर्तनों का पूर्वावलोकन करें",
@@ -412,6 +413,7 @@ export const hi: RebaseTranslations = {
     flatten_arrays: "ऐरे को फ़्लैट करें",
     download: "डाउनलोड",
     large_number_of_documents: "इस संग्रह में बड़ी संख्या में दस्तावेज़ हैं ({{count}})।",
+    too_many_documents_to_export: "इस संग्रह में इतने दस्तावेज़ ({{count}}) हैं कि ब्राउज़र उन्हें एक ही फ़ाइल में निर्यात नहीं कर सकता (सीमा {{limit}})। निर्यात से पहले इसे फ़िल्टर करें।",
     include_undefined_values: "अपरिभाषित (undefined) मान शामिल करें",
     submit: "सबमिट करें",
 

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",
@@ -412,6 +413,7 @@ export const it: RebaseTranslations = {
     flatten_arrays: "Appiattisci gli array",
     download: "Scarica",
     large_number_of_documents: "Questa collezione contiene un numero elevato di documenti ({{count}})",
+    too_many_documents_to_export: "Questa collezione contiene più documenti ({{count}}) di quanti il browser possa esportarne in un solo file (limite {{limit}}). Filtrala prima di esportare.",
     include_undefined_values: "Includi valori non definiti",
     submit: "Invia",
 

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",
@@ -417,6 +418,7 @@ export const pt: RebaseTranslations = {
     flatten_arrays: "Achatar listas",
     download: "Descarregar",
     large_number_of_documents: "Esta coleção tem um grande número de documentos ({{count}}).",
+    too_many_documents_to_export: "Esta coleção tem mais documentos ({{count}}) do que o navegador consegue exportar num único ficheiro (limite {{limit}}). Filtre-a antes de exportar.",
     include_undefined_values: "Incluir valores indefinidos",
     submit: "Submeter",