@wix/himalaya-cli 0.982.0 → 0.984.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/notification-preferences/src/index.d.ts

@@ -5,56 +5,128 @@ declare global {
         };
     };
 }
-/** "MUTED" silences the topic on this channel; "UNMUTED" delivers it. */
+/**
+ * The service's own mount, from the published swagger `host`
+ * ("www.wixapis.com/notification-preferences") — the PATH half of it.
+ *
+ * Relative, not absolute: the `wixApi` bridge supplies the gateway host. Baking one in
+ * works on a phone and is rejected in a browser (`400 absolute_urls_not_allowed`), so a
+ * client that spells the host works in one place and not the other. What was wrong
+ * before was the mount (`/notifications`), not the host.
+ */
+export declare const NOTIFICATION_PREFERENCES_BASE = "/notification-preferences/v1";
+/** `enum State` on `StateData`. A scalar, not an object. */
+export type PreferenceState = "MUTED" | "UNMUTED" | string;
+/** Kept as the name the callers already use for the value they write. */
 export type MuteStatus = "MUTED" | "UNMUTED";
-/** Delivery channel. The mobile push channel value is unconfirmed; "MOBILE" is
- *  the working default the bundle passes. */
-export type Channel = "MOBILE" | string;
-export interface PreferenceState {
-    /** "MUTED" | "UNMUTED" — whether the topic is delivered on this channel. */
-    muteStatus?: MuteStatus;
-}
-export interface PreferenceStateData {
+/** `enum Channel { UNKNOWN_CHANNEL, ALL, MOBILE, EMAIL, SMS, VOICE, BROWSER, WEB_FEED }`.
+ *  `ALL` is real and covers mobile too — filtering it out hides preferences that do
+ *  apply on this surface. */
+export type Channel = "ALL" | "MOBILE" | "EMAIL" | "SMS" | "VOICE" | "BROWSER" | "WEB_FEED" | string;
+export type RecipientType = "WIX_USER" | "CONTACT";
+/** `message StateData`. `granted` and `overridden` are read-only server verdicts. */
+export interface StateData {
+    /** The state the recipient asked for. */
     state?: PreferenceState;
+    /** Whether the notification is granted to be SENT. An UNMUTED topic under a muted
+     *  channel is `granted: false` — i.e. the row must not render ON. */
+    granted?: boolean;
+    /** Whether a broader rule overrides this row, so it cannot be changed here. */
+    overridden?: boolean;
+    displayName?: string;
 }
-/** One topic×channel preference for the implicit recipient. */
+/** `message PreferenceInfo` — one topic×channel preference. */
 export interface PreferenceInfo {
-    /** The notification topic id (matches NotificationTopic.id). */
     topicId: string;
-    /** Delivery channel this preference applies to (e.g. "MOBILE"). */
     channel?: Channel;
-    stateData?: PreferenceStateData;
+    stateData?: StateData;
+    topicType?: string;
 }
+/** `message NotificationPreferences`. */
 export interface NotificationPreferences {
     preferencesInfo?: PreferenceInfo[];
 }
+/** `GetPreferencesBy{Implicit,}RecipientResponse` uses `notification_preferences`;
+ *  `UpsertPreferencesBy{Implicit,}RecipientResponse` uses `preferences`. Both are
+ *  declared so a caller cannot read the wrong one by accident. */
 export interface GetMyNotificationPreferencesResponse {
+    notificationPreferences?: NotificationPreferences;
+}
+export interface UpsertMyNotificationPreferencesResponse {
     preferences?: NotificationPreferences;
 }
-/** A notification topic — its id is the PreferenceInfo.topicId; displayName is
- *  the row label shown in the UI. */
-export interface NotificationTopic {
-    id: string;
+/** `message NotificationTopicDefinition`. */
+export interface NotificationTopicDefinition {
+    topicId: string;
     displayName?: string;
+    state?: PreferenceState;
+    topicType?: string;
 }
+/** `GetNotificationTopicsDefinitionsResponse.preference_definitions`. */
 export interface GetNotificationTopicsResponse {
-    topics?: NotificationTopic[];
-}
-export interface UpsertMyNotificationPreferencesRequest {
-    preferencesInfo: PreferenceInfo[];
+    preferenceDefinitions?: NotificationTopicDefinition[];
 }
-export interface UpsertMyNotificationPreferencesResponse {
-    preferences?: NotificationPreferences;
-}
-/** Map a UI "on" boolean to a MuteStatus: on ⇒ delivered ("UNMUTED"). */
+/** The topic list, or empty when the response carried none. */
+export declare function readTopics(res: GetNotificationTopicsResponse | undefined): NotificationTopicDefinition[];
+/** The preference rows out of EITHER response shape (see the asymmetry note above). */
+export declare function readPreferences(res: GetMyNotificationPreferencesResponse | UpsertMyNotificationPreferencesResponse | undefined): PreferenceInfo[];
+/** Map a UI "on" boolean to the state to WRITE: on ⇒ delivered ("UNMUTED"). */
 export declare function muteStatusFor(on: boolean): MuteStatus;
-/** Get the signed-in member's notification preferences —
- *  GET /notifications/v1/preferences-by-implicit-recipient. */
-export declare function getMyNotificationPreferences(): Promise<GetMyNotificationPreferencesResponse>;
-/** List the available notification topics (id + displayName for labels) —
- *  GET /notifications/v1/preferences/topics. */
+/**
+ * Whether this row is actually being delivered right now.
+ *
+ * `granted` is the server's verdict and beats `state`: a topic the recipient unmuted
+ * under a channel they muted is `state: "UNMUTED", granted: false`. Rendering `state`
+ * alone shows ON for a notification that will never arrive.
+ */
+export declare function isDeliveredNow(stateData: StateData | undefined): boolean;
+/** Whether a broader rule overrides this row, so the UI must not offer to change it. */
+export declare function isLocked(stateData: StateData | undefined): boolean;
+/**
+ * The one preference row that governs `topicId` on `channel`, or undefined when the
+ * recipient has no row for it (⇒ the topic's default, which is delivery).
+ *
+ * A topic can carry SEVERAL rows — one per channel, plus a channel-wide `ALL` — and
+ * the response order is not specified. Picking with a bare `find` therefore rendered
+ * whichever row the service happened to list first, so a mobile switch could show an
+ * EMAIL preference, and a MOBILE + ALL pair flipped meaning between two identical
+ * reads. Resolved by SPECIFICITY instead: the exact channel wins, then `ALL`, then a
+ * row that names no channel at all.
+ */
+export declare function preferenceFor(topicId: string, prefs: readonly PreferenceInfo[], channel?: Channel): PreferenceInfo | undefined;
+/**
+ * Per-topic "is this actually being delivered on `channel`" verdicts.
+ *
+ * A topic with no row is absent from the map, not false: absent means "the topic's
+ * own default", which the caller renders as ON.
+ */
+export declare function deliveredByTopic(prefs: readonly PreferenceInfo[], channel?: Channel): Record<string, boolean>;
+/** List the site's notification topics — `GET /v1/preferences/topics`
+ *  (GetNotificationTopicsDefinitions). Publicly mounted.
+ *  verify-live: source contract checked; live caller authorization remains untested. */
 export declare function getNotificationTopics(): Promise<GetNotificationTopicsResponse>;
-/** Upsert one or more of the signed-in member's preferences —
- *  POST /notifications/v1/preferences-by-implicit-recipient, body
- *  { preferencesInfo }. Pass only the rows that changed. */
+/**
+ * The PUBLICLY mounted preferences read — `GET /v1/preferences`
+ * (GetPreferencesByRecipient). It needs the recipient explicitly: `CONTACT` + a
+ * contactId for a member, `WIX_USER` + a wixUserId for an owner.
+ *
+ * Prefer this from an app going through the public gateway; the implicit-recipient
+ * variant below is not among the five paths the swagger exposes.
+ * verify-live: source contract checked; live caller authorization remains untested.
+ */
+export declare function getPreferencesForRecipient(recipient: {
+    recipientType: RecipientType;
+    contactId?: string;
+    wixUserId?: string;
+    language?: string;
+}): Promise<GetMyNotificationPreferencesResponse>;
+/** The signed-in recipient's preferences — `GET /v1/preferences-by-implicit-recipient`
+ *  (GetPreferencesByImplicitRecipient). NOT in the published public swagger; a 404 from
+ *  the public gateway is the expected outcome there, not a bug in this call.
+ *  verify-live: the implicit-recipient mount has not been verified for member callers. */
+export declare function getMyNotificationPreferences(): Promise<GetMyNotificationPreferencesResponse>;
+/** Upsert some of the signed-in recipient's preferences —
+ *  `POST /v1/preferences-by-implicit-recipient` (UpsertPreferencesByImplicitRecipient),
+ *  body `{ preferencesInfo }`. Pass only the rows that changed.
+ *  verify-live: the implicit-recipient mount has not been verified for member callers. */
 export declare function upsertMyNotificationPreferences(preferencesInfo: PreferenceInfo[]): Promise<UpsertMyNotificationPreferencesResponse>;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-notification-preferences.mjs

@@ -5,27 +5,88 @@ function wixCall(method, path, body, headers) {
   }
   return globalThis.himalaya.wixApi.call(method, path, body, headers);
 }
-var BASE = "/notifications/v1";
+var NOTIFICATION_PREFERENCES_BASE = "/notification-preferences/v1";
+function readTopics(res) {
+  return res?.preferenceDefinitions ?? [];
+}
+function readPreferences(res) {
+  const container = res?.notificationPreferences ?? res?.preferences;
+  return container?.preferencesInfo ?? [];
+}
 function muteStatusFor(on) {
   return on ? "UNMUTED" : "MUTED";
 }
-function getMyNotificationPreferences() {
-  return wixCall("GET", `${BASE}/preferences-by-implicit-recipient`);
+function isDeliveredNow(stateData) {
+  if (!stateData) return false;
+  if (typeof stateData.granted === "boolean") return stateData.granted;
+  return stateData.state === "UNMUTED";
+}
+function isLocked(stateData) {
+  return stateData?.overridden === true;
+}
+function preferenceFor(topicId, prefs, channel = "MOBILE") {
+  let allRow;
+  let unscoped;
+  for (const p of prefs) {
+    if (p.topicId !== topicId) continue;
+    if (p.channel === channel) return p;
+    if (p.channel === "ALL") allRow ?? (allRow = p);
+    else if (!p.channel) unscoped ?? (unscoped = p);
+  }
+  return allRow ?? unscoped;
+}
+function deliveredByTopic(prefs, channel = "MOBILE") {
+  const out = {};
+  for (const p of prefs) {
+    if (!p.topicId || p.topicId in out) continue;
+    const governing = preferenceFor(p.topicId, prefs, channel);
+    if (governing) out[p.topicId] = isDeliveredNow(governing.stateData);
+  }
+  return out;
 }
 function getNotificationTopics() {
-  return wixCall("GET", `${BASE}/preferences/topics`);
+  return wixCall(
+    "GET",
+    `${NOTIFICATION_PREFERENCES_BASE}/preferences/topics`
+  );
+}
+function getPreferencesForRecipient(recipient) {
+  const query = Object.entries({
+    recipientType: recipient.recipientType,
+    contactId: recipient.contactId,
+    wixUserId: recipient.wixUserId,
+    language: recipient.language
+  }).filter(([, value]) => Boolean(value)).map(([key, value]) => `${key}=${encodeURIComponent(value ?? "")}`).join("&");
+  return wixCall(
+    "GET",
+    `${NOTIFICATION_PREFERENCES_BASE}/preferences?${query}`
+  );
+}
+function getMyNotificationPreferences() {
+  return wixCall(
+    "GET",
+    `${NOTIFICATION_PREFERENCES_BASE}/preferences-by-implicit-recipient`
+  );
 }
 function upsertMyNotificationPreferences(preferencesInfo) {
   return wixCall(
     "POST",
-    `${BASE}/preferences-by-implicit-recipient`,
+    `${NOTIFICATION_PREFERENCES_BASE}/preferences-by-implicit-recipient`,
     { preferencesInfo }
   );
 }
 export {
+  NOTIFICATION_PREFERENCES_BASE,
+  deliveredByTopic,
   getMyNotificationPreferences,
   getNotificationTopics,
+  getPreferencesForRecipient,
+  isDeliveredNow,
+  isLocked,
   muteStatusFor,
+  preferenceFor,
+  readPreferences,
+  readTopics,
   upsertMyNotificationPreferences
 };
 //# sourceMappingURL=wix-notification-preferences.mjs.map