@wix/himalaya-cli 0.980.0 → 0.982.0

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

@@ -95,3 +95,34 @@ export declare function listDelivered(): Promise<DeliveredNotification[]>;
 export declare function clearDelivered(ids?: string[]): Promise<void>;
 /** Capability version, for bundles that gate on min binary version. */
 export declare const version = 1;
+/** One notification, as a worker sees it. Every field is always present; an
+ *  absent one reads as `""` rather than `undefined`, so a `$service:` binding at
+ *  a field this payload omitted renders nothing instead of the text "undefined". */
+export interface NotificationEvent {
+    /** Ping template that produced it, e.g. "stores.order_shipped". */
+    templateId: string;
+    /** Ping topic, e.g. "stores". */
+    topic: string;
+    /** The site the payload named, when it named one. */
+    metaSiteId: string;
+    /** Stable per-notification id — the key to deduplicate on. */
+    notificationId: string;
+    /** The link exactly as delivered, before any route translation. */
+    link: string;
+    /** What the route table translated `link` into, or `""` when no route
+     *  matched. Empty is NOT an error: the notification still arrived, and a
+     *  worker may want to count one it cannot open. */
+    resolvedLink: string;
+    /** True only when the user TAPPED. A foreground receipt is `false` and must
+     *  not be treated as intent to navigate. */
+    tapped: boolean;
+}
+/**
+ * Read the params a dispatched `observerAction` receives.
+ *
+ * Runs on the untrusted edge of the bridge, so it never throws whatever arrives.
+ * `tapped` needs this reader more than the rest: the bridge stringifies every
+ * param, so a worker testing `params.tapped` truthily would read the string
+ * `"false"` as a tap.
+ */
+export declare function readNotificationEvent(params: unknown): NotificationEvent;

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

@@ -80,6 +80,38 @@ export interface AppCommerceConfig {
     /** Copy-pack overrides for the paywall. */
     copy?: Record<string, string>;
 }
+/**
+ * RFC 0059 §3.2 — the idiom policy: which named overlay from `tokens.json`'s `idiom` block a
+ * surface wears. `policy` is a tag, and each value owns its own sibling fields; the union
+ * makes the type checker reject the combinations the RFC rules out, not only the gate
+ * (`core/dev-server/tests/idiom-overlay-parity.test.ts`).
+ *
+ * - `follow-surface` (the default INSIDE a declared block): each surface wears the overlay
+ *   for its own idiom — `ios` on the iOS renderer, `material` on Android, `desktop` on a
+ *   desktop-class window. `surfaces` pins individual surfaces, keyed by catalog surface id
+ *   like `NavigationConfig.surfaces`; `fallback` names the overlay for a surface with no
+ *   idiom of its own. An overlay the app never authored resolves to base.
+ * - `pinned`: every surface wears the one overlay `pin` names. `surfaces` is not allowed —
+ *   pinning one overlay and then overriding it per surface is `follow-surface`.
+ * - `none`: a declared opt-out. Same pixels as omitting the block, but on the record.
+ */
+export type IdiomPolicy = {
+    policy?: "follow-surface";
+    /** Catalog surface id (`phone` | `tablet` | `desktop` | `mac` | …) → overlay name. */
+    surfaces?: Record<string, string>;
+    fallback?: string;
+    pin?: never;
+} | {
+    policy: "pinned";
+    pin: string;
+    surfaces?: never;
+    fallback?: never;
+} | {
+    policy: "none";
+    surfaces?: never;
+    fallback?: never;
+    pin?: never;
+};
 export interface AppConfig {
     /** Reverse-DNS app id, e.g. "com.wix.owner". */
     id: string;
@@ -338,6 +370,14 @@ export interface AppConfig {
     workerSubtreeScreens?: string[];
     /** RFC 0010 — navigation structure + deep-link mapping, served OTA. */
     navigation?: NavigationConfig;
+    /**
+     * RFC 0059 — how each surface picks its overlay from `tokens.json`'s `idiom` block.
+     *
+     * Two defaults, deliberately different: OMIT this block and the policy is `none` (base
+     * tokens, byte-identical to an app that never heard of idiom); DECLARE it without a
+     * `policy` and you get `follow-surface`. See `IdiomPolicy`.
+     */
+    idiom?: IdiomPolicy;
     /**
      * App-declared Wix REST cache rules. The app controls per-endpoint opt-out
      * (`cacheable: false`) and TTL; the server renders the EFFECTIVE policy by

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

@@ -0,0 +1,59 @@
+import type { IdiomPolicy } from "./define-app.js";
+/** What a runtime tells the resolver about where it is drawing. */
+export interface IdiomContext {
+    /**
+     * The overlays this runtime natively wears, most specific first: `["ios"]` on iOS,
+     * `["material"]` on Android, `["desktop", "ios"]` on macOS (RFC 0059 §7.1: a Mac wears
+     * `desktop`, falling back to `ios` when the app authored no `desktop` overlay). Empty ⇒ no
+     * native idiom (the web, today), so only `surfaces`, `fallback` or a pin can select one.
+     */
+    native?: readonly string[];
+    /** Catalog surface id this frame renders on (`phone`, `tablet`, `mac`, …); keys `surfaces`. */
+    surface?: string;
+}
+/** The token-document fields resolution reads. `idiomPolicy` is stamped from `config.ts`. */
+export interface IdiomDocument {
+    idiom?: Record<string, unknown>;
+    idiomPolicy?: IdiomPolicy;
+}
+/** The runtime contexts, in one place so the web host, RN and the tests agree on the names. */
+export declare const IDIOM_CONTEXTS: {
+    readonly ios: {
+        readonly native: readonly ["ios"];
+    };
+    readonly android: {
+        readonly native: readonly ["material"];
+    };
+    readonly mac: {
+        readonly native: readonly ["desktop", "ios"];
+        readonly surface: "mac";
+    };
+};
+/**
+ * The overlay a surface wears, or `undefined` for the base look. Never throws: an absent or
+ * malformed policy, or a name the app never authored, resolves to base (RFC 0059 §3.3).
+ *
+ *   - no policy, or `none`          → base
+ *   - `pinned`                      → `pin`
+ *   - `follow-surface` (the default inside a declared block), first AUTHORED of:
+ *       `surfaces[ctx.surface]`, then each of `ctx.native`, then `fallback`.
+ */
+export declare function selectIdiomOverlay(doc: IdiomDocument, ctx?: IdiomContext): string | undefined;
+/**
+ * Deep-merge one overlay over a base token document: objects merge key by key, and arrays and
+ * scalars replace. One rule is colour-specific, because a colour token has two shapes: a
+ * per-appearance overlay (`{ "dark": "#…" }`) over a single-hex base keeps the base as its
+ * `light` arm, so restyling one appearance never erases the others.
+ */
+export declare function mergeIdiomOverlay<T extends Record<string, unknown>>(base: T, overlay: Record<string, unknown>): T;
+/**
+ * The token document a surface actually wears. Returns the SAME object when no overlay is
+ * selected, so an app that declares no idiom resolves byte-identically to before (the #2924
+ * opt-in guarantee).
+ *
+ * Resolution is FINAL: the merged result drops `idiomPolicy`, so resolving it again is a no-op
+ * under any context. That matters because resolved tokens get re-resolved — a scoped-theme
+ * subtree re-derives its resolvers from them, a native runtime may re-register `current` — and
+ * a second pass under a different context must not stack another overlay on the first.
+ */
+export declare function resolveIdiom<T extends object>(tokens: T, ctx?: IdiomContext): T;

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

@@ -9,6 +9,7 @@ export * from "./validation.js";
 export * from "./widget-vocabulary.js";
 export * from "./preview-surfaces.js";
 export * from "./tokens.js";
+export * from "./idiom.js";
 export * from "./tier-caps.js";
 export * from "./flags.js";
 export * from "./flags-engine.js";

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

@@ -1,3 +1,4 @@
+import type { IdiomPolicy } from "./define-app.js";
 export type ColorScheme = "light" | "dark" | "highContrast";
 export type ColorValue = string | {
     light: string;
@@ -38,7 +39,28 @@ export interface DesignTokens {
      *  a comfortable column and a tablet/desktop fills more without running edge to
      *  edge. Absent ⇒ platform default (web 480/760, native fill). */
     contentMaxWidth?: ResponsiveSize;
+    /** RFC 0059 — named idiom overlays, keyed by IDIOM (`ios`, `material`, `desktop`), not by
+     *  platform. Which one a surface wears is `config.ts`'s `idiom` policy; with no policy the
+     *  block is inert and base tokens resolve exactly as before. */
+    idiom?: Record<string, IdiomOverlay>;
+    /** RFC 0059 — the app's `config.ts` `idiom` policy, STAMPED into the served document by the
+     *  dev-server (and so into every release snapshot) so each runtime can select an overlay
+     *  in `register` with no second fetch. Derived, never authored in `tokens.json`. */
+    idiomPolicy?: IdiomPolicy;
 }
+/** Every field optional, at every depth: an idiom overlay restyles only what it names. */
+export type DeepPartial<T> = T extends readonly (infer U)[] ? readonly DeepPartial<U>[] : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * RFC 0059 §3.1 — one named idiom overlay: a partial token set deep-merged over the base,
+ * before appearance (`light`/`dark`/`highContrast`) resolves. It may only restyle tokens the
+ * base already declares — `core/dev-server/tests/idiom-overlay-parity.test.ts` enforces that.
+ *
+ * Not overlayable: `contentMaxWidth` (a Projection concern that RFC 0041 size classes own),
+ * `fontFaces` (the served font declaration, derived rather than authored) and `idiom` itself.
+ */
+export type IdiomOverlay = DeepPartial<Omit<DesignTokens, "idiom" | "idiomPolicy" | "contentMaxWidth" | "fontFaces">>;
 /**
  * One face in a font declaration.
  *

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

@@ -9434,6 +9434,69 @@ function isComponentAllowed(surface, componentType) {
   return row[gate.family] ? { allowed: true } : { allowed: false, reason: `not in the ${gate.family} allowlist` };
 }
 
+// ../../core/ts/src/idiom.ts
+var IDIOM_CONTEXTS = {
+  ios: { native: ["ios"] },
+  android: { native: ["material"] },
+  mac: { native: ["desktop", "ios"], surface: "mac" }
+};
+function authored(overlays, name) {
+  return typeof name === "string" && overlays !== void 0 && Object.hasOwn(overlays, name) && overlays[name] !== null && typeof overlays[name] === "object" && !Array.isArray(overlays[name]);
+}
+function selectIdiomOverlay(doc, ctx = {}) {
+  const policy = doc.idiomPolicy;
+  const overlays = doc.idiom;
+  const isRecord3 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+  if (!isRecord3(policy) || !isRecord3(overlays)) return void 0;
+  const kind = policy.policy ?? "follow-surface";
+  if (kind === "none") return void 0;
+  if (kind === "pinned") return authored(overlays, policy.pin) ? policy.pin : void 0;
+  if (kind !== "follow-surface") return void 0;
+  const surfaces = policy.surfaces;
+  const candidates = [
+    ctx.surface !== void 0 && isRecord3(surfaces) && Object.hasOwn(surfaces, ctx.surface) ? surfaces[ctx.surface] : void 0,
+    ...ctx.native ?? [],
+    policy.fallback
+  ];
+  return candidates.find((c) => authored(overlays, c));
+}
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function deepMerge(base, overlay) {
+  if (!isPlainObject(overlay) || !isPlainObject(base)) return overlay;
+  const out = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (UNSAFE_KEYS.has(key)) continue;
+    out[key] = Object.hasOwn(base, key) ? deepMerge(base[key], value) : value;
+  }
+  return out;
+}
+function mergeIdiomOverlay(base, overlay) {
+  const merged = deepMerge(base, overlay);
+  const baseColors = base.colors;
+  const overlayColors = overlay.colors;
+  if (isPlainObject(baseColors) && isPlainObject(overlayColors)) {
+    const colors = { ...merged.colors };
+    for (const [name, value] of Object.entries(overlayColors)) {
+      if (UNSAFE_KEYS.has(name)) continue;
+      const was = Object.hasOwn(baseColors, name) ? baseColors[name] : void 0;
+      if (typeof was === "string" && isPlainObject(value)) colors[name] = { light: was, ...value };
+    }
+    merged.colors = colors;
+  }
+  return merged;
+}
+function resolveIdiom(tokens, ctx = {}) {
+  const doc = tokens;
+  const name = selectIdiomOverlay(doc, ctx);
+  if (name === void 0) return tokens;
+  const merged = mergeIdiomOverlay(tokens, doc.idiom[name]);
+  const { idiomPolicy: _applied, ...final } = merged;
+  return final;
+}
+
 // ../../core/ts/src/tier-caps.ts
 function summarize(descriptor) {
   const rendererTier = descriptor.renderer === "sdui_intent" ? "tier1" : descriptor.renderer === "sdui_layout" ? "tier2" : descriptor.renderer === "webview_native_bridge" ? "tier3" : "tier4";
@@ -12825,6 +12888,7 @@ export {
   ICON_NORMALIZED_INDEX,
   ICON_STROKE_WIDTH,
   ICON_VIEW_BOX,
+  IDIOM_CONTEXTS,
   LAUNCH_MANIFEST_SCHEMA,
   LAUNCH_NAMESPACE,
   LINK_MOUNT_PATHS,
@@ -12889,12 +12953,14 @@ export {
   isViewTarget,
   isWidgetFamilySurface,
   layoutDirection,
+  mergeIdiomOverlay,
   parseNumeric,
   primarySubtag,
   resolveAppIdentity,
   resolveAppLocale,
   resolveColor,
   resolveIcon,
+  resolveIdiom,
   resolveKeyboard,
   resolveMode,
   resolveOrientationEnvelope,
@@ -12904,6 +12970,7 @@ export {
   resolveSurfaceNav,
   resolveSurfaceViewKey,
   screenDescriptorSchema,
+  selectIdiomOverlay,
   shouldRevealError,
   stripOriginParams,
   summarize,

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

@@ -70,6 +70,26 @@ function normalizePermission(s) {
   return s === "granted" || s === "denied" ? s : "undetermined";
 }
 var version = 1;
+function readNotificationEvent(params) {
+  const p = params && typeof params === "object" ? params : {};
+  const str = (key) => {
+    const v = p[key];
+    if (v === void 0 || v === null) return "";
+    return typeof v === "string" ? v : String(v);
+  };
+  const raw = str("tapped").toLowerCase();
+  return {
+    templateId: str("templateId"),
+    topic: str("topic"),
+    metaSiteId: str("metaSiteId"),
+    notificationId: str("notificationId"),
+    link: str("link"),
+    resolvedLink: str("resolvedLink"),
+    // Absent or unrecognized ⇒ a RECEIPT. Guessing "tap" would navigate a user
+    // who never asked to go anywhere.
+    tapped: raw === "true" || raw === "1"
+  };
+}
 export {
   cancelAllLocal,
   cancelLocal,
@@ -79,6 +99,7 @@ export {
   getDeviceToken,
   getPermissionStatus,
   listDelivered,
+  readNotificationEvent,
   requestPermission,
   scheduleLocal,
   setBadge,