@wix/himalaya-cli 0.1406.0 → 0.1408.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/builder.d.ts

@@ -872,6 +872,7 @@ export declare function listItem(props: {
     accessory?: "none" | "chevron" | "checkmark";
     titleStyle?: string;
     subtitleStyle?: string;
+    markdown?: boolean;
 }, opts?: {
     id?: string;
 }): Component;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/wix-cache-policy.d.ts

@@ -6,11 +6,74 @@ export interface WixCacheRule {
     ttl: number;
     swr: number;
     tag: string | null;
+    queueOffline?: true;
+    /** How a resend of this write is deduplicated (§2.1). The client applies what it receives. */
+    idempotency?: OfflineIdempotency;
+    /** Seconds a queued write may wait before it is dead-lettered as `expired` (§6), already clamped. */
+    queueMaxAge?: number;
 }
+/** RFC 0072 §2.1 — how an endpoint dedupes a resend after an ambiguous attempt. */
+export type OfflineIdempotency = "header" | "clientId" | "conflictIsApplied" | "unsentOnly";
 export interface WixCachePolicy {
     rules: WixCacheRule[];
     defaultCacheable: boolean;
 }
+/** One endpoint whose writes may queue offline (§2.1): a method, ONE exact path, and the dedupe
+ *  mechanism Task 0 observed live, with the evidence. An app rule queues only when it names this
+ *  endpoint exactly — a prefix would take in its siblings (`/wix-data/v2/items` covers
+ *  `/wix-data/v2/items/bulk/remove`), whose dedupe nobody verified. */
+export interface OfflineQueueableEndpoint {
+    method: string;
+    path: string;
+    idempotency: OfflineIdempotency;
+    /** The write carries personal data even where no personal read prefix says so (§6). */
+    personal: boolean;
+    /** Where the Task 0 probe that justifies `idempotency` is recorded. */
+    evidence: string;
+}
+/** RFC 0072 §2.1 — deny-by-default: a write queues only if its endpoint is here. No row exists
+ *  until its Task 0 probe is recorded, and none assumes an endpoint honours `Idempotency-Key`. */
+export declare const OFFLINE_QUEUEABLE: readonly OfflineQueueableEndpoint[];
+/** RFC 0072 §2.1 — never queueable, whatever an app declares: money, identity, stored value and
+ *  capacity holds. `/gift-cards` and `/loyalty` have no trailing slash on purpose
+ *  (`/loyalty-accounts/v1/accounts/{id}/adjust-points`). Checked before the allow-table. */
+export declare const NEVER_QUEUEABLE_PREFIXES: readonly string[];
+/** RFC 0072 §2.1 — a path any of whose segments, split on `-`, is one of these is never queueable:
+ *  every checkout, payment, order, refund and hold route, under whatever allow prefix it sits. */
+export declare const NEVER_QUEUEABLE_TOKENS: readonly string[];
+/** RFC 0072 §6 — personal WRITES the personal-read list misses: a form submission carries a name,
+ *  an email and a phone. */
+export declare const OFFLINE_PERSONAL_WRITE_PREFIXES: readonly string[];
+/** RFC 0072 §6 (D2) — how long a queued write may wait: 7 days, or 24 hours for personal data. */
+export declare const OFFLINE_MAX_AGE: number;
+export declare const OFFLINE_PERSONAL_MAX_AGE = 86400;
+/** RFC 0072 §2.1 — whether `path` is on the never-queueable floor. Every client runs the same
+ *  check on the concrete call path (core/schema/fixtures/offline-writes/never-queueable.json). */
+export declare function isNeverQueueable(path: string): boolean;
+/** Why a declared `queueOffline` rule does not queue, as a stable code (§2.2). */
+export type OfflineQueueRefusalCode = "never_queueable" | "not_queueable" | "missing_method" | "missing_tag" | "absolute_url";
+export interface OfflineQueueRefusal {
+    code: OfflineQueueRefusalCode;
+    method: string | null;
+    pathPrefix: string;
+}
+/** Every rule of `declared` that asks to queue offline but will not, with the coded reason, so
+ *  `himalaya-dev app validate` and the dev-server can say so instead of dropping it silently. */
+export declare function offlineQueueRefusals(declared?: DeclaredWixCache, table?: readonly OfflineQueueableEndpoint[]): OfflineQueueRefusal[];
+/** RFC 0072 §2.2 — the effective queueing of one app rule:
+ *  `app_wants AND on OFFLINE_QUEUEABLE AND NOT never_queueable AND method AND tag`, with the
+ *  mechanism and the clamped max age stamped on, so no client needs the table. */
+export declare function stampOfflineQueue(rule: WixCacheRule, declared: {
+    queueOffline?: boolean;
+    queueMaxAge?: number;
+}, table?: readonly OfflineQueueableEndpoint[]): WixCacheRule;
+/** RFC 0072 §2.2 — re-vet every queue rule of a served `wixCachePolicy` against the allow-table.
+ *  An operator overlay (or an admin override) is deep-merged OVER the stamped policy, and its
+ *  `rules` array replaces the stamped one wholesale — so a rule it carries with `queueOffline`
+ *  would otherwise reach every client unchecked, with any mechanism and any max age. Here such a
+ *  rule is stamped exactly like an app's own (or stripped), so the served queueing is always the
+ *  table's. Rules without a queue key pass through untouched. */
+export declare function sanitizeServedOfflineQueue<T>(policy: T, table?: readonly OfflineQueueableEndpoint[]): T;
 /** The path a rule's prefix names: itself, or the path of an absolute `https://host/path` prefix
  *  (an account-level read a worker makes to a full Wix URL) — so the platform denies apply to it. */
 export declare function rulePath(pathPrefix: string): string;
@@ -34,4 +97,4 @@ export type DeclaredWixCache = AppCacheConfig;
  *      `defaultCacheable: true` can never make a PII path cacheable by matching nothing.
  * Everything is clamped under the platform envelope (PII denies, TTL ceiling).
  */
-export declare function resolveWixCachePolicy(appName: string, declared?: DeclaredWixCache): WixCachePolicy;
+export declare function resolveWixCachePolicy(appName: string, declared?: DeclaredWixCache, queueable?: readonly OfflineQueueableEndpoint[]): WixCachePolicy;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/wix-platform/src/index.d.ts

@@ -198,3 +198,4 @@ export declare const monitoring: {
 };
 /** Capability version, for bundles that gate on min binary version. */
 export declare const version = 2;
+export { offline, isOfflineWriteBlocked, isOfflineWriteOutcomeUnknown, type Sent, type Queued, type OfflineResult, type OfflineEvent, type OfflineEventType, type PendingWrite, type RejectedWrite, } from "./offline.js";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/wix-platform/src/offline.d.ts

@@ -0,0 +1,66 @@
+/** The endpoint answered: `value` is what the call would have returned without the option. */
+export interface Sent<T> {
+    status: "sent";
+    value: T;
+}
+/** The write waits in the outbox; `writeId` identifies it in events, `pending()` and `rejected()`. */
+export interface Queued {
+    status: "queued";
+    writeId: string;
+    tag: string;
+}
+export type OfflineResult<T> = Sent<T> | Queued;
+export type OfflineEventType = "queued" | "applied" | "rejected";
+export interface OfflineEvent {
+    writeId: string;
+    tag: string;
+    status?: number;
+    code?: string;
+    reason?: string;
+}
+export interface PendingWrite {
+    writeId: string;
+    tag: string;
+    createdAt: number;
+    attempts: number;
+}
+export interface RejectedWrite {
+    writeId: string;
+    tag: string;
+    /** `http` | `conflict` | `expired` | `outcome_unknown` | `unauthorized`. */
+    reason: string;
+    status?: number;
+    code?: string;
+    method: string;
+    pathTemplate: string;
+    createdAt: number;
+    rejectedAt: number;
+    /** The request body, while the write has not expired: for "retry" or "copy your text". */
+    body?: string;
+}
+/** `wixApi.call` with `{ offline: "queue" }`. On a runtime without offline writes the call is a plain
+ *  live call, reported as `sent`. */
+declare function call<T>(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<OfflineResult<T>>;
+/** The two offline errors a worker branches on (`err.code`). */
+export declare function isOfflineWriteBlocked(e: unknown): e is Error & {
+    code: "offline_write_blocked";
+    reason: string;
+};
+/** An `unsentOnly` write whose outcome is unknown: say "we couldn't confirm this went through". */
+export declare function isOfflineWriteOutcomeUnknown(e: unknown): e is Error & {
+    code: "offline_write_outcome_unknown";
+};
+export declare const offline: {
+    call: typeof call;
+    /** This scope's queued writes (no bodies). */
+    pending: (opts?: {
+        tag?: string;
+    }) => Promise<PendingWrite[]>;
+    /** This scope's rejected writes. */
+    rejected: () => Promise<RejectedWrite[]>;
+    /** Clear one rejected write. A retry is a new write with a new `writeId`. */
+    dismiss: (writeId: string) => Promise<boolean>;
+    /** `queued`, `applied` and `rejected`, delivered while this worker runs. Returns an unsubscribe. */
+    on: (type: OfflineEventType, cb: (e: OfflineEvent) => void) => (() => void);
+};
+export {};

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/define-app.d.ts

@@ -676,6 +676,16 @@ export interface AppCacheRule {
     swr?: number;
     /** Resource family for write-through purge, e.g. "stores/products". */
     tag?: string;
+    /**
+     * RFC 0072 — let a worker queue this endpoint's writes while offline (`{ offline: "queue" }` at
+     * the call site). Default false. Takes effect only where the platform allow-table lists the
+     * endpoint (method + this exact path) and it is not a payment, identity, stored-value or hold
+     * route; `method` and `tag` are then required. The server stamps the dedupe mechanism.
+     */
+    queueOffline?: boolean;
+    /** Seconds a queued write may wait before it is dropped as expired. Clamped to 7 days, and to
+     *  24 hours for personal data. Defaults to that ceiling. */
+    queueMaxAge?: number;
 }
 export interface AppCacheConfig {
     /** Behavior for a request no rule matches. Defaults to false (deny). */

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/schema.d.ts

@@ -1255,6 +1255,10 @@ export interface ListItemProps {
     subtitleStyle?: TokenName;
     /** #1049 — title color token. Default `textPrimary`. */
     titleColor?: TokenName;
+    /** Parse `title`/`subtitle` as inline Markdown (the `Text.markdown` subset: bold,
+     *  italic, code, links) — a literal, `$t:` key or `$item.` value; a live `$service:`
+     *  value renders literally, as for Text. `overline` stays literal. */
+    markdown?: boolean;
     /** #1049 — subtitle color token. Default `textSecondary`. */
     subtitleColor?: TokenName;
     /** #1049 — overline color token. Default `textSecondary`. */

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

@@ -13,9 +13,39 @@ function dispatch(handlerId, params, _options) {
   return himalaya.dispatch(handlerId, stringParams);
 }
 
+// ../../core/sdk/wix-platform/src/offline.ts
+function bridge() {
+  const himalaya = globalThis.himalaya;
+  return himalaya ? himalaya.wixApi : void 0;
+}
+async function call(method, path, body, headers) {
+  const api = bridge();
+  if (!api) throw new Error("wixApi bridge unavailable");
+  if (!api.offline) return { status: "sent", value: await api.call(method, path, body, headers) };
+  return await api.call(method, path, body, headers, { offline: "queue" });
+}
+function isOfflineWriteBlocked(e) {
+  return e?.code === "offline_write_blocked";
+}
+function isOfflineWriteOutcomeUnknown(e) {
+  return e?.code === "offline_write_outcome_unknown";
+}
+var offline = {
+  call,
+  /** This scope's queued writes (no bodies). */
+  pending: (opts) => bridge()?.offline?.pending(opts) ?? Promise.resolve([]),
+  /** This scope's rejected writes. */
+  rejected: () => bridge()?.offline?.rejected() ?? Promise.resolve([]),
+  /** Clear one rejected write. A retry is a new write with a new `writeId`. */
+  dismiss: (writeId) => bridge()?.offline?.dismiss(writeId) ?? Promise.resolve(false),
+  /** `queued`, `applied` and `rejected`, delivered while this worker runs. Returns an unsubscribe. */
+  on: (type, cb) => bridge()?.offline?.on(type, cb) ?? (() => {
+  })
+};
+
 // ../../core/sdk/wix-platform/src/index.ts
 var CAP = "capability.wix_platform";
-async function call(method, params) {
+async function call2(method, params) {
   return await dispatch(`${CAP}.${method}`, params);
 }
 function wpHost() {
@@ -33,7 +63,7 @@ async function realWix(method, path, body) {
 var bi = {
   /** Fire a BI beacon with an explicit Frog `evid` + params. */
   async track(evid, params) {
-    const r = await call("biTrack", {
+    const r = await call2("biTrack", {
       evid: String(evid),
       params: params ? JSON.stringify(params) : ""
     });
@@ -79,11 +109,11 @@ async function conductCached(ns, spec, fallback, resolve) {
   return task;
 }
 async function resolveExperiment(spec, fallback) {
-  const r = await call("experimentsConduct", { spec, fallback });
+  const r = await call2("experimentsConduct", { spec, fallback });
   return typeof r?.variant === "string" ? r.variant : null;
 }
 async function resolveFlag(spec, fallback) {
-  const r = await call("flagsIsEnabled", { spec, fallback });
+  const r = await call2("flagsIsEnabled", { spec, fallback });
   return typeof r?.enabled === "boolean" ? String(r.enabled) : null;
 }
 var experiments = {
@@ -101,7 +131,7 @@ var experiments = {
    *  (Symphony relies on server-side conduction; this is the generalized app-side
    *  exposure hook.) */
   async exposure(spec, variant) {
-    const r = await call("experimentsExposure", { spec, variant });
+    const r = await call2("experimentsExposure", { spec, variant });
     return { ok: r?.ok ?? false };
   }
 };
@@ -114,12 +144,12 @@ var flags = {
   },
   /** A toggle's raw value (variant string) for non-boolean specs. */
   async value(spec, fallback = "") {
-    const r = await call("flagsValue", { spec, fallback });
+    const r = await call2("flagsValue", { spec, fallback });
     return r?.value ?? fallback;
   },
   /** All known toggle states (dev/diagnostic). */
   async all() {
-    const r = await call("flagsAll");
+    const r = await call2("flagsAll");
     return r?.flags && typeof r.flags === "object" ? r.flags : {};
   }
 };
@@ -129,31 +159,31 @@ var i18n = {
    *  has no route on any Wix host a himi app reaches (the same 404 as a made-up path, with or
    *  without a token), so `real.i18n` no longer sends it anywhere — it only ever 404ed. */
   async t(key, fallback) {
-    const r = await call("i18nTranslate", { key, fallback: fallback ?? key });
+    const r = await call2("i18nTranslate", { key, fallback: fallback ?? key });
     return r?.value ?? fallback ?? key;
   },
   /** Current resolved UI locale (2-letter). */
   async locale() {
-    const r = await call("i18nLocale");
+    const r = await call2("i18nLocale");
     return r?.locale ?? "en";
   }
 };
 var ping = {
   /** Register the device's push token with Wix Ping. */
   async register() {
-    const r = await call("pingRegister");
+    const r = await call2("pingRegister");
     return { registered: r?.registered ?? false, token: r?.token ?? "" };
   },
   /** Current Ping registration status (no network). */
   async status() {
-    const r = await call("pingStatus");
+    const r = await call2("pingStatus");
     return { registered: r?.registered ?? false, token: r?.token ?? "" };
   }
 };
 var deeplink = {
   /** Resolve a deferred (post-install) deep link via Wix Jot. Null when none. */
   async resolveDeferred() {
-    const r = await call("deeplinkResolveDeferred");
+    const r = await call2("deeplinkResolveDeferred");
     return { link: r?.link && r.link.length > 0 ? r.link : null };
   }
 };
@@ -161,24 +191,24 @@ var session = {
   /** The Wix mobile aspect-headers the transport attaches to wix-host requests
    *  (BSI, x-wix-language, mobile-app-version, x-wix-rpc-caller-id, …). */
   async headers() {
-    const r = await call("sessionHeaders");
+    const r = await call2("sessionHeaders");
     return r?.headers && typeof r.headers === "object" ? r.headers : {};
   },
   /** Whether a per-business signed instance is minted, and for which metaSite. */
   async signedInstanceStatus() {
-    const r = await call("sessionSignedInstance");
+    const r = await call2("sessionSignedInstance");
     return { present: r?.present ?? false, msid: r?.msid ?? null };
   }
 };
 async function authTransition(method) {
-  await call(method);
+  await call2(method);
   dropConductFlights();
   return auth.getIdentity();
 }
 var auth = {
   /** Current identity (visitor vs member vs owner) + who. */
   async getIdentity() {
-    const r = await call("authIdentity");
+    const r = await call2("authIdentity");
     return {
       authenticated: r?.authenticated ?? false,
       type: r?.type ?? "anonymous",
@@ -192,7 +222,7 @@ var auth = {
   },
   /** The current access/member token (or null when anonymous). */
   async getAccessToken() {
-    const r = await call("authAccessToken");
+    const r = await call2("authAccessToken");
     return r?.token && r.token.length > 0 ? r.token : null;
   },
   /** Sign in (hosted Wix login → member token). Resolves with the new identity. */
@@ -224,7 +254,7 @@ var auth = {
       } catch {
       }
     }
-    const r = await call("authSignedInstance", { businessId, type });
+    const r = await call2("authSignedInstance", { businessId, type });
     return r?.signedInstance && r.signedInstance.length > 0 ? r.signedInstance : null;
   }
 };
@@ -258,7 +288,7 @@ function parseBusinessInfo(res) {
 }
 async function scopeToSite(msid) {
   try {
-    const r = await call("siteSetActive", { msid });
+    const r = await call2("siteSetActive", { msid });
     return { ok: !!r?.ok, msid: r?.msid ?? "" };
   } finally {
     dropConductFlights();
@@ -271,7 +301,7 @@ var site = {
   },
   /** The metaSiteId currently scoped ("" if none). */
   async activeSite() {
-    const r = await call("siteActive");
+    const r = await call2("siteActive");
     return r?.msid ?? "";
   },
   /** The customer's business/site info (identity + locale + contact) from Wix Site
@@ -328,7 +358,7 @@ var site = {
 var monitoring = {
   /** Capture a handled error message (routes to the Sentry telemetry sink). */
   async captureError(message, extra) {
-    const r = await call("monitoringCapture", {
+    const r = await call2("monitoringCapture", {
       message,
       extra: extra ? JSON.stringify(extra) : ""
     });
@@ -336,7 +366,7 @@ var monitoring = {
   },
   /** Capture an exception with an error class + message (crash-style report). */
   async captureException(errorClass, message, extra) {
-    const r = await call("monitoringCaptureException", {
+    const r = await call2("monitoringCaptureException", {
       errorClass,
       message,
       extra: extra ? JSON.stringify(extra) : ""
@@ -345,15 +375,15 @@ var monitoring = {
   },
   /** Associate the current user with subsequent crash reports. */
   async setUser(userId, traits) {
-    await call("monitoringSetUser", { userId, traits: traits ? JSON.stringify(traits) : "" });
+    await call2("monitoringSetUser", { userId, traits: traits ? JSON.stringify(traits) : "" });
   },
   /** Set a scope tag attached to subsequent crash reports. */
   async setTag(key, value) {
-    await call("monitoringSetTag", { key, value });
+    await call2("monitoringSetTag", { key, value });
   },
   /** Drop a breadcrumb onto the crash trail. */
   async addBreadcrumb(message) {
-    await call("monitoringBreadcrumb", { message });
+    await call2("monitoringBreadcrumb", { message });
   }
 };
 var version = 2;
@@ -365,7 +395,10 @@ export {
   flags,
   i18n,
   isMemberReal,
+  isOfflineWriteBlocked,
+  isOfflineWriteOutcomeUnknown,
   monitoring,
+  offline,
   ping,
   session,
   site,