@riverbankcms/sdk 0.144.0 → 0.145.0

package/dist/_dts/content-model/src/content-types/schema.d.ts

@@ -10,6 +10,7 @@ declare const BaseContentFieldSchema: z.ZodObject<{
         link: "link";
         date: "date";
         text: "text";
+        group: "group";
         url: "url";
         textarea: "textarea";
         select: "select";
@@ -17,7 +18,6 @@ declare const BaseContentFieldSchema: z.ZodObject<{
         reference: "reference";
         repeater: "repeater";
         file: "file";
-        group: "group";
         datetime: "datetime";
         button: "button";
         richText: "richText";

package/dist/_dts/core/src/appointment-service-categories.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The one grouping authority for appointment-service categories (issue 1403).
+ *
+ * Every surface that shows services by category — the public services list,
+ * the booking selector, the dashboard Services page and the CSV export — goes
+ * through `layoutServicesByCategory` rather than deciding grouping itself.
+ *
+ * Ordering is not decided here. The database owns it (category `sort_order`,
+ * then service `sort_order` within its group, with title and id as
+ * tie-breakers) and the reads hand both lists over already ordered. This
+ * module only buckets, and it preserves input order inside every bucket, so a
+ * client never re-sorts into an order the reorder compare-and-swap would not
+ * recognise.
+ */
+/** What a visitor may know about a category: its heading and optional intro. */
+export type ServiceCategorySummary = Readonly<{
+    id: string;
+    name: string;
+    description: string | null;
+}>;
+/** Anything carrying the category it belongs to; null is the "Other" group. */
+export type CategorizedService = Readonly<{
+    categoryId: string | null;
+}>;
+export type ServiceCategoryGroup<TService, TCategory extends Readonly<{
+    id: string;
+}> = ServiceCategorySummary> = Readonly<{
+    category: TCategory;
+    services: readonly TService[];
+}>;
+/**
+ * `uncategorized-site` means there is nothing to group by, so the list stays
+ * flat exactly as before categories existed. That is when the site has **no
+ * categories at all**, decided by the category list and never inferred from
+ * which categories the services happen to reference. On public surfaces
+ * (`keepEmptyGroups: false`) it is also when no category has any of the
+ * listed services, so visitors never see a lone "Other" heading (W20).
+ *
+ * `categorized-site` carries the groups in category order and `other`, the
+ * uncategorised services, which always sort last. `other` may be empty:
+ * whether an empty Other is shown is the caller's decision (the public list
+ * omits it, the dashboard always shows it).
+ */
+export type ServiceCategoryLayout<TService, TCategory extends Readonly<{
+    id: string;
+}> = ServiceCategorySummary> = Readonly<{
+    kind: 'uncategorized-site';
+    services: readonly TService[];
+}> | Readonly<{
+    kind: 'categorized-site';
+    groups: readonly ServiceCategoryGroup<TService, TCategory>[];
+    other: readonly TService[];
+}>;
+export type LayoutServicesByCategoryOptions = Readonly<{
+    /**
+     * Public surfaces drop categories with no services. The dashboard keeps
+     * them so it can show "No services in this category yet".
+     */
+    keepEmptyGroups: boolean;
+}>;
+/**
+ * Groups services under their categories.
+ *
+ * A service whose `categoryId` names no category in `categories` lands in
+ * Other. The composite foreign key keeps that from happening with stored data,
+ * so this is only the total, safe answer for a caller holding a stale list.
+ */
+export declare function layoutServicesByCategory<TService extends CategorizedService, TCategory extends Readonly<{
+    id: string;
+}>>(categories: readonly TCategory[], services: readonly TService[], options: LayoutServicesByCategoryOptions): ServiceCategoryLayout<TService, TCategory>;
+/** The services in display order: each group in turn, then Other. */
+export declare function flattenServiceCategoryLayout<TService, TCategory extends Readonly<{
+    id: string;
+}>>(layout: ServiceCategoryLayout<TService, TCategory>): TService[];
+/**
+ * What a block filtered to (at most) one category should show.
+ *
+ * - `all`: no filter is set, so every non-empty group shows, Other last.
+ * - `single`: the filter names one of the site's categories. The group can be
+ *   empty, which the caller renders as its empty state.
+ * - `fallback-all`: the filter names a category the site no longer has (it was
+ *   deleted), so everything shows, grouped. This is a first-class state rather
+ *   than a null check so the editor can warn about it.
+ */
+export type ServiceCategoryView<TService, TCategory extends Readonly<{
+    id: string;
+}> = ServiceCategorySummary> = Readonly<{
+    kind: 'all';
+    layout: ServiceCategoryLayout<TService, TCategory>;
+}> | Readonly<{
+    kind: 'single';
+    group: ServiceCategoryGroup<TService, TCategory>;
+}> | Readonly<{
+    kind: 'fallback-all';
+    missingCategoryId: string;
+    layout: ServiceCategoryLayout<TService, TCategory>;
+}>;
+/**
+ * Selects the public view for an optional category filter.
+ *
+ * It takes the category and service lists rather than a prebuilt layout
+ * because the public layout has already dropped empty categories, and then an
+ * empty category (`single` with no services) could not be told apart from a
+ * deleted one (`fallback-all`).
+ */
+export declare function selectCategoryView<TService extends CategorizedService, TCategory extends Readonly<{
+    id: string;
+}>>(categories: readonly TCategory[], services: readonly TService[], filterCategoryId: string | null | undefined): ServiceCategoryView<TService, TCategory>;

package/dist/_dts/core/src/editor-state.d.ts

@@ -63,6 +63,12 @@ export type EditorBlockPublishedBaselineInput = Readonly<{
 }>;
 export type EditorPersistedBlock = Readonly<{
     id: EditorBlockId;
+    /**
+     * The content version the block was loaded with. Runtime blocks that
+     * submit to the API (newsletter signup) cite it so the server can verify
+     * the placement, so the editor must carry it rather than strip it.
+     */
+    contentVersionId?: string | null;
     kind: string;
     content: EditorBlockValues | null;
     orderIndex: number | null;

package/dist/_dts/core/src/index.d.ts

@@ -18,6 +18,7 @@ export * from './booking-refunds';
 export * from './booking-instalments';
 export * from './booking-date-time';
 export * from './booking-consent';
+export * from './appointment-service-categories';
 export * from './dated-offering-settlement';
 export * from './person-records';
 export * from './rectification';

package/dist/_dts/core/src/public-profile.d.ts

@@ -104,4 +104,13 @@ export declare function parsePublicProfile(value: unknown): Result<PublicProfile
  * holds a business address for every profile saved before the switch existed.
  */
 export declare function resolvePublicProfilePremises(profile: PublicProfile, hasBusinessAddress: boolean): boolean;
+/**
+ * The contact details the site may publish: the stored contact with every
+ * hidden method removed, or null when nothing is left to show.
+ *
+ * Every public reader goes through this. The privacy policy identity is the
+ * one exception and reads the stored email directly, because a hidden email
+ * can still be the policy's contact.
+ */
+export declare function publishedContactDetails(profile: Pick<PublicProfile, 'contact' | 'contactVisibility'>): PublicContactDetails | null;
 export declare function emptyPublicProfile(): PublicProfile;