@rebasepro/admin 0.13.0 → 0.13.1-canary.g394d868

package/src/util/number_format.ts

@@ -0,0 +1,46 @@
+import type { NumberFormatOptions } from "@rebasepro/admin-types";
+
+/**
+ * Write a number out for reading, per a property's declared `admin.format`.
+ *
+ * Nothing is inferred here. With no options the number is returned as it came
+ * out of the database — `String(value)`, not a locale-grouped rendering — so a
+ * panel that declares nothing shows exactly the stored value, and an author who
+ * wants thousands separators asks for them.
+ *
+ * `Intl.NumberFormat` throws on a bad currency code or an out-of-range fraction
+ * count, and a record must not blank because one property is misconfigured, so a
+ * failure falls back to the raw value.
+ */
+export function formatNumber(
+    value: number,
+    options: NumberFormatOptions | undefined,
+    fallbackLocale?: string
+): string {
+
+    if (!options) return String(value);
+
+    // A currency code is the whole declaration in the common case: writing
+    // `{ currency: "EUR" }` and getting a bare `185.11` because `style` was
+    // omitted is a trap, and there is nothing else `currency` could mean.
+    const style = options.style ?? (options.currency ? "currency" : "decimal");
+
+    if (style === "currency" && !options.currency) {
+        // `Intl` throws on this rather than picking a currency, which is the
+        // right call — there is no sensible default — but the record still has
+        // to render.
+        return String(value);
+    }
+
+    try {
+        return new Intl.NumberFormat(options.locale ?? fallbackLocale ?? undefined, {
+            style,
+            currency: options.currency,
+            minimumFractionDigits: options.minimumFractionDigits,
+            maximumFractionDigits: options.maximumFractionDigits,
+            notation: options.notation
+        }).format(value);
+    } catch {
+        return String(value);
+    }
+}

package/src/util/previews.ts

@@ -1,64 +1,17 @@
 import type { Property } from "@rebasepro/types";
 import type { PropertyConfig, AdminCollection } from "@rebasepro/admin-types";
-import { AuthController } from "@rebasepro/admin-types";
-import { isPropertyBuilder } from "@rebasepro/common";
 import { getTitlePropertyKey, getTitlePropertyKeyForValues } from "@rebasepro/app";
-import { isReferenceProperty, isRelationProperty } from "./property_utils";
-
-function isHiddenProperty(property: Property | undefined): boolean {
-    if (!property) return false;
-    return Boolean(property.admin?.hideFromCollection);
-}
+import { isPropertyBuilder } from "@rebasepro/common";
 
 /**
- * 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.
+ * Which properties fill a preview surface, best first.
+ *
+ * The implementation lives in `@rebasepro/app` so that the admin package and
+ * the app package cannot disagree about what a record looks like in a card —
+ * they had drifted, and only one of the two copies had learned to keep
+ * relations out of the list.
  */
-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>,
-    fields: Record<string, PropertyConfig>,
-    previewProperties?: string[],
-    limit = 3) {
-    const allProperties = Object.keys(targetCollection.properties);
-    let listProperties = previewProperties?.filter(p => allProperties.includes(p as string));
-    if (!listProperties && targetCollection.previewProperties) {
-        listProperties = targetCollection.previewProperties?.filter(p => allProperties.includes(p as string));
-    }
-    if (listProperties && listProperties.length > 0) {
-        return listProperties;
-    } else {
-        const hasExplicitOrder = !!(targetCollection.propertiesOrder as string[] | undefined);
-        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) && !isHiddenProperty(property)
-                    && !isStorageProperty(property as Property)
-                    && (hasExplicitOrder || !isRelationProperty(property));
-            }).slice(0, limit);
-    }
-}
+export { getEntityPreviewKeys } from "@rebasepro/app";
 
 /**
  * The property that fills the title slot for a collection.

package/src/util/property_utils.tsx

@@ -159,8 +159,13 @@ export function getResolvedPropertyInPath(properties: Record<string, Property>,
         }
         if (path.includes(".")) {
             const pathSegments = path.split(".");
+            // A path whose root is not a property at all is simply not found.
+            // Reading `.type` off the miss threw a TypeError instead, which
+            // turned one unresolvable column key into a crash for whatever was
+            // walking the properties — see `propertiesToColumns`, where that is
+            // the whole table. `getPropertyInPath` above already guards this.
             const childProperty = properties[pathSegments[0]];
-            if (childProperty.type === "map" && childProperty.properties) {
+            if (childProperty?.type === "map" && childProperty.properties) {
                 return getResolvedPropertyInPath(childProperty.properties, pathSegments.slice(1).join("."))
             }
         }