@wix/himalaya-cli 0.1079.0 → 0.1081.0

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

@@ -134,6 +134,8 @@ export interface WebViewConfig {
     internalLinksAsScreens?: boolean;
     respectHttpCache?: boolean;
     coverBandColor?: string;
+    hideWixAds?: boolean;
+    hideHostedSiteFooter?: boolean;
 }
 export declare function vstack(props: {
     spacing?: number;
@@ -378,6 +380,24 @@ export declare function dataTable(props: {
 }, opts?: {
     id?: string;
 }): Component;
+/**
+ * RFC 0063 — a Wix Ricos document rendered natively (never a WebView). Pass exactly one of
+ * `documentJsonPath` (`$service:<service>.<path>` / `$item.<field>` → the JSON string a worker
+ * published, e.g. `encodeRichContent(doc).json`) or `documentJson` (a literal seed document).
+ * The id is REQUIRED: child test ids are `<id>/<blockId>` (invariant 27). `onLink` receives
+ * `args.url`; without it http(s) links open in the in-app browser. `fallback` renders when the
+ * document is rejected (over budget / invalid); nothing inside the document is ever resolved
+ * as a binding.
+ */
+export declare function richContent(props: {
+    documentJsonPath?: string;
+    documentJson?: string;
+    onLink?: ActionShape;
+    fallback?: Component;
+}, opts: {
+    id: string;
+    modifiers?: NonNullable<Component["modifiers"]>;
+}): Component;
 export declare function spacer(opts?: {
     id?: string;
     value?: string;

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

@@ -1519,6 +1519,23 @@ export interface DataTableProps {
     maxRows?: number;
     zebra?: boolean;
 }
+/**
+ * RFC 0063 — a Wix Ricos rich-content document rendered natively: headings, lists, links,
+ * images, galleries, video, tables and link cards (never a WebView). The document travels as a
+ * JSON STRING so every renderer caps its bytes before parsing (RFC 0046's precedent) and a
+ * `$item.` row substitution carries it intact. Exactly one of `documentJsonPath` /
+ * `documentJson` is set. Nothing inside the document is ever resolved as a binding.
+ */
+export interface RichContentProps {
+    /** `$service:<svc>.<path>` or `$item.<field>` → the UTF-8 JSON of `{ nodes, metadata?, documentStyle? }`. */
+    documentJsonPath?: string;
+    /** Literal document JSON (seed / offline). */
+    documentJson?: string;
+    /** Dispatched on a link, button or card tap with `args.url`. Absent ⇒ http(s) opens the in-app browser. */
+    onLink?: Action;
+    /** Rendered when the document is rejected (over budget / invalid). Absent ⇒ nothing. */
+    fallback?: Component;
+}
 /**
  * A recorded-audio message bubble — waveform, play/pause, scrubber, duration and
  * playback rate (messenger design G4).
@@ -2324,6 +2341,10 @@ export type CoreComponentBody = {
     package: "himalaya";
     type: "DataTable";
     props: DataTableProps;
+} | {
+    package: "himalaya";
+    type: "RichContent";
+    props: RichContentProps;
 } | {
     package: "himalaya";
     type: "VoiceNote";
@@ -2708,7 +2729,12 @@ export interface SplashConfig {
     /** Hard ceiling on the readiness hold, ms — a stuck boot can never wedge the
      *  UI. 0 / absent ⇒ 3000. Clamped client-side to [0, 8000]. */
     maxHoldMs?: number;
+    /** RFC 0062 — what readiness waits for beyond the seed. Absent / "" ⇒ seeded is
+     *  enough. "first_content" ⇒ also the first WebView page (a site shell), still
+     *  under `maxHoldMs`. Unknown coalesces to "" on device. */
+    readySignal?: SplashReadySignal;
 }
+export type SplashReadySignal = "" | "first_content";
 export interface DeepLinkPattern {
     /** e.g. "wix-owner://blog/post/:id" */
     pattern: string;
@@ -2913,9 +2939,44 @@ export interface WebViewConfig {
      * cover is recreated on every present, so without this each open is a cold reload
      * (multi-second for a heavy SPA). With it, the host caches the WebView per screenId
      * (LRU) and re-shows the already-loaded page instantly — in-app login/session and
-     * scroll position are preserved. iOS-implemented; Android ignores it (cold-loads) for now.
+     * scroll position are preserved. Both platforms (WebViewKeepAliveStore, keyed by screen id).
      */
     keepAlive?: boolean;
+    /**
+     * Pin an uncooperative hosted site's own header (`position: relative` on mobile, so it
+     * scrolls away) to the top while the page scrolls — an app-like sticky menu. Injected CSS
+     * makes it `position: sticky` under the safe-area inset with an opaque background.
+     */
+    pinHostedHeader?: boolean;
+    /**
+     * Turn internal navigations (real links + Wix SPA pushState routes) into native pushed
+     * WebView screens with native back/close, kept warm in an LRU pool. Enable only on
+     * hosted-site covers. See docs/webview-internal-links-as-screens.md.
+     */
+    internalLinksAsScreens?: boolean;
+    /**
+     * Honour the origin's HTTP caching (revalidate per Cache-Control). Default prefers a cached
+     * copy for a faster load; set true for screens that must always be fresh. An explicit
+     * `cacheMode` still wins.
+     */
+    respectHttpCache?: boolean;
+    /**
+     * Fallback band colour (any CSS colour). The dynamic band reads the site's own
+     * `<meta name="theme-color">`; this colour is used until/when the site declares none. On
+     * web (a cross-origin iframe can't be read) it is the only band source.
+     */
+    coverBandColor?: string;
+    /**
+     * RFC 0062 — hide the Wix free-site ads banner (`WIX_ADS`) and keep it hidden as the page
+     * mutates. The script ships in the app binary; only this flag travels over the air, so an
+     * owner can turn ads back on without a new build. No-op on web (cross-origin iframe).
+     */
+    hideWixAds?: boolean;
+    /**
+     * RFC 0062 — hide the hosted site's OWN footer (the native chrome replaces it). Binary-shipped
+     * script, like {@link hideHostedSiteHeader}. No-op on web (cross-origin iframe).
+     */
+    hideHostedSiteFooter?: boolean;
 }
 /**
  * Embeddable WebView component (web-in-SDUI). WebViews have no intrinsic height,

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

@@ -87,20 +87,6 @@ export declare function siteAllowedOrigins(origin: string, kind: SiteKind): stri
 export declare function sitePageUrl(origin: string, path: string): string;
 /** `site_<page.id>`. */
 export declare function siteScreenId(page: Pick<SitePage, "id">): string;
-/**
- * Hide the hosted site's footer and/or the Wix ads banner, and keep them hidden as the
- * page mutates. Ported from `generateElementHidingScript` in the Wix RN app
- * (`@wix/hybrid-mobile-platform`), minus the header branch — header hiding is the
- * native `hideHostedSiteHeader` path, which keeps the home page's header.
- *
- * Interim delivery: this rides `injectJsDocumentEnd`. RFC 0062 phase 2 replaces it
- * with a binary-shipped adapter selected by id (`hostedSiteAdapter` + `hideWixAds`),
- * so no raw page script travels over the air.
- */
-export declare function siteChromeHidingScript(options: {
-    hideFooter: boolean;
-    hideWixAds: boolean;
-}): string;
 /** Resolved chrome flags — every absent flag is `true`. */
 export declare function resolveSiteChrome(chrome: SiteChrome | undefined): Required<SiteChrome>;
 /**

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

@@ -1033,6 +1033,24 @@ export declare const screenDescriptorSchema: {
                 readonly keepAlive: {
                     readonly type: "boolean";
                 };
+                readonly pinHostedHeader: {
+                    readonly type: "boolean";
+                };
+                readonly internalLinksAsScreens: {
+                    readonly type: "boolean";
+                };
+                readonly respectHttpCache: {
+                    readonly type: "boolean";
+                };
+                readonly coverBandColor: {
+                    readonly type: "string";
+                };
+                readonly hideWixAds: {
+                    readonly type: "boolean";
+                };
+                readonly hideHostedSiteFooter: {
+                    readonly type: "boolean";
+                };
             };
         };
     };
@@ -1976,6 +1994,24 @@ export declare const widgetSnapshotSchema: {
                 readonly keepAlive: {
                     readonly type: "boolean";
                 };
+                readonly pinHostedHeader: {
+                    readonly type: "boolean";
+                };
+                readonly internalLinksAsScreens: {
+                    readonly type: "boolean";
+                };
+                readonly respectHttpCache: {
+                    readonly type: "boolean";
+                };
+                readonly coverBandColor: {
+                    readonly type: "string";
+                };
+                readonly hideWixAds: {
+                    readonly type: "boolean";
+                };
+                readonly hideHostedSiteFooter: {
+                    readonly type: "boolean";
+                };
             };
         };
     };

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/rich-content/src/display.d.ts

@@ -0,0 +1,26 @@
+export type ImageHolder = {
+    image?: {
+        src?: {
+            url?: unknown;
+            id?: unknown;
+        };
+    };
+} | undefined;
+/** Trims ASCII whitespace only — the set every platform's trim agrees on. Used for LINKS: the viewer applies the
+ *  link rule to the value itself, so anything else at the ends (a BOM, a no-break space) stays and the rule then
+ *  refuses it, rather than one renderer's trim accepting it. Media references are instead normalized by
+ *  normalizeMediaRef, which trims fully: the encoder repairs media (ids resolved, Wix urls sized and upgraded) and
+ *  emits the normalized value, so the url a renderer later checks carries no padding for any trim to disagree on. */
+export declare function trimAscii(s: string): string;
+/** A link as the viewer emits it: the trimmed value when it passes the link rule (http(s) with a host, mailto,
+ *  tel), undefined when it does not. */
+export declare function cleanLink(url: unknown): string | undefined;
+/** The sized https URL for the image a Ricos holder points at (`imageData`, `{ image: galleryItem.image.media }`,
+ *  `{ image: videoData.thumbnail }`): a Wix id or Wix URL is sized to `width` by wixMediaUrl, other https URLs pass
+ *  through unchanged, anything else (non-Wix http, data:, relative, unknown) is "". */
+export declare function ricosImageUrl(holder: ImageHolder, width: number): string;
+/** A URL the viewer can show for a Ricos video `src`, decided in the viewer's order: an http(s) YouTube or Vimeo
+ *  link that passes the link rule is a card (its url a link, ASCII-trimmed); any other https url is played natively
+ *  (media, normalized); a Wix video id becomes its video.wixstatic.com file. "" otherwise — including a card-host
+ *  url that fails the link rule, which never gets a second chance as media. */
+export declare function ricosVideoUrl(src: unknown): string;

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

@@ -0,0 +1,79 @@
+/** One Ricos node: a block (PARAGRAPH, HEADING, IMAGE, …) or an inline TEXT run. Type-specific data
+ *  (`imageData`, `headingData`, …) rides along as extra keys. */
+export type RicosNode = {
+    type?: string;
+    id?: string;
+    nodes?: RicosNode[];
+    textData?: {
+        text?: string;
+        decorations?: {
+            type: string;
+            linkData?: {
+                link?: {
+                    url?: string;
+                };
+            };
+        }[];
+    };
+    [k: string]: unknown;
+};
+/** A Ricos document with its `nodes` checked to be an array (what parseRicosJson and plainTextToRicos return). */
+export type RicosDocument = {
+    nodes: RicosNode[];
+    metadata?: unknown;
+    documentStyle?: unknown;
+};
+/** Any Ricos-shaped value, as Wix APIs return it (a blog post's `richContent`, an event's description) — their
+ *  generated types declare `nodes` loosely, so the helpers accept it as is and check the shape at runtime. */
+export type RicosInput = {
+    nodes?: unknown;
+    metadata?: unknown;
+    documentStyle?: unknown;
+};
+/** Why a document is not shown: the viewer draws its fallback instead and reports only this code. */
+export type RejectReason = "invalid_json" | "too_large" | "too_many_nodes" | "too_deep" | "not_a_document";
+/** The RichContent viewer's ceilings; every renderer rejects a document past any of them. Kept equal to the platform limits file by a test. */
+export declare const RICH_CONTENT_LIMITS: {
+    readonly maxBytes: 262144;
+    readonly maxNodes: 5000;
+    readonly maxDepth: 16;
+};
+/** Reads a Ricos document from a JSON string or an already-parsed object (page messages arrive as either,
+ *  depending on the platform). Returns null for empty input, invalid JSON, or anything without a `nodes` array. */
+export declare function parseRicosJson(value: unknown): RicosDocument | null;
+/** Plain text of a document. Paragraphs, headings and loose text runs are blocks joined by a blank line; runs
+ *  inside a block join with nothing between them, so a word split across bold and plain runs stays one word.
+ *  Media and other nodes contribute only the text nested inside them. Malformed parts (a non-object node, a
+ *  `nodes` that is not an array) contribute nothing — it never throws. */
+export declare function ricosToPlainText(doc: RicosInput | null | undefined): string;
+/** A document of undecorated paragraphs, one per blank-line-separated block of `text` — the inverse of
+ *  ricosToPlainText for plain text. An empty string gives one empty paragraph. */
+export declare function plainTextToRicos(text: string): RicosDocument;
+/** True when a plain-text editor can rewrite the document without losing anything: no document styling, and
+ *  only paragraphs of undecorated text runs whose paragraph settings are the defaults a plain paragraph carries
+ *  (`{ textStyle: { textAlignment: "AUTO" }, indentation: 0 }`, or none). A heading, list, link, bold run,
+ *  media node, alignment or indent makes it rich. A missing or empty document (no `nodes`, or `[]`) is plain —
+ *  there is nothing in it to lose. Anything malformed is not: a value that is not a document object (a JSON
+ *  string, an array), or `nodes` that is not an array, so a caller holding the wrong shape never overwrites it. */
+export declare function isPlainRicos(doc: RicosInput | null | undefined): boolean;
+/** True when an HTML description has no formatting to protect: empty, text with no tag in it (a lone `<` in
+ *  prose is text), or exactly one attribute-free `<p>` around text with no inner tags. A form that edits plain
+ *  text may overwrite only these. */
+export declare function htmlIsTrivial(html: string | null | undefined): boolean;
+/** Prepares a Ricos document for the RichContent viewer; bind the returned `json` as `documentJsonPath`.
+ *  Wix media ids become sized https URLs (`imageWidth`, default and maximum 1400 px; galleries and posters at most
+ *  1000). Block ids follow the viewer's own rule on the encoded document — a block's missing, all-digits-and-dots
+ *  or repeated id becomes its path index there ("0.2.1") — so every renderer shows the same ids and encoding twice
+ *  changes nothing. Images, galleries and videos without https media (an http YouTube or Vimeo link is kept: the
+ *  viewer shows it as a card), buttons without an http(s)/mailto/tel link, any other link url with a disallowed
+ *  scheme (link decorations, card and image links) and inline HTML (`htmlData.html`, an embed's `oembed.html`) are
+ *  removed; an allowed link is emitted trimmed of surrounding whitespace, as the viewer emits it. Text is never
+ *  changed. Keys are sorted, so equal documents encode to equal strings. The input is not
+ *  modified. A missing or empty document gives `{ json: "" }`; a non-document or one past the viewer's limits gives
+ *  `{ json: "", rejected }` (checked in the order not_a_document, too_deep, too_large, too_many_nodes). */
+export declare function encodeRichContent(doc: RicosInput | null | undefined, opts?: {
+    imageWidth?: number;
+}): {
+    json: string;
+    rejected?: RejectReason;
+};

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

@@ -7606,6 +7606,7 @@ function validateConfigShape(config) {
 var SPLASH_MIN_VISIBLE_MS_MAX = 2e3;
 var SPLASH_MAX_HOLD_MS_MAX = 8e3;
 var SPLASH_LAYOUTS = ["centered", "centeredStacked", "logoOnly"];
+var SPLASH_READY_SIGNALS = ["", "first_content"];
 function validateA11y(a11y) {
   if (!a11y || typeof a11y !== "object" || Array.isArray(a11y)) {
     throw new Error('defineApp: a11y must be an object like { enforce: "warn" }.');
@@ -7739,6 +7740,11 @@ function validateSplash(splash, colors, tokensPath) {
       `defineApp: splash.layout "${splash.layout}" is not one of ${SPLASH_LAYOUTS.join(", ")}.`
     );
   }
+  if (splash.readySignal !== void 0 && !SPLASH_READY_SIGNALS.includes(splash.readySignal)) {
+    throw new Error(
+      `defineApp: splash.readySignal "${splash.readySignal}" is not one of "", "first_content".`
+    );
+  }
   for (const [field, value, max] of [
     ["logoWidth", splash.logoWidth, 1024],
     ["minVisibleMs", splash.minVisibleMs, SPLASH_MIN_VISIBLE_MS_MAX],
@@ -8534,9 +8540,17 @@ var screenDescriptorSchema = {
         hideHostedSiteHeader: { type: "boolean" },
         immersive: { type: "boolean" },
         showCloseButton: { type: "boolean" },
-        // Keep the native WebView instance warm across re-presentations (covers reload cold
-        // otherwise). iOS-implemented; Android ignores it (cold-loads) for now.
-        keepAlive: { type: "boolean" }
+        // Keep the native WebView instance warm across re-presentations and tab switches
+        // (per screen id, LRU — WebViewKeepAliveStore on both platforms).
+        keepAlive: { type: "boolean" },
+        // Hosted-site polish — native hosts honoured these before the validator knew them.
+        pinHostedHeader: { type: "boolean" },
+        internalLinksAsScreens: { type: "boolean" },
+        respectHttpCache: { type: "boolean" },
+        coverBandColor: { type: "string" },
+        // RFC 0062 — binary-shipped chrome hiding for a hosted site (no page script over the air).
+        hideWixAds: { type: "boolean" },
+        hideHostedSiteFooter: { type: "boolean" }
       }
     }
   }
@@ -8668,6 +8682,8 @@ var CORE_COMPONENTS = /* @__PURE__ */ new Set([
   "himalaya.DonutChart",
   "himalaya.Legend",
   "himalaya.DataTable",
+  // Rich content — RFC 0063
+  "himalaya.RichContent",
   // Recorded-audio bubble — messenger design G4
   "himalaya.VoiceNote",
   "himalaya.Marquee",
@@ -13034,47 +13050,6 @@ function sitePageUrl(origin, path) {
 function siteScreenId(page) {
   return `${SITE_SCREEN_PREFIX}${page.id}`;
 }
-function siteChromeHidingScript(options) {
-  if (!options.hideFooter && !options.hideWixAds) return "";
-  return `(function(){
-  if (window.__himiSiteChromeHider) return;
-  window.__himiSiteChromeHider = true;
-  var HIDE_FOOTER = ${options.hideFooter ? "true" : "false"};
-  var HIDE_ADS = ${options.hideWixAds ? "true" : "false"};
-  function hide(el, collapse) {
-    if (!el) return;
-    el.style.display = 'none';
-    el.style.visibility = 'hidden';
-    if (collapse) { el.style.height = '0px'; el.style.overflow = 'hidden'; }
-  }
-  function pass() {
-    if (HIDE_FOOTER) {
-      hide(document.getElementsByTagName('footer')[0] ||
-        document.querySelector('footer[id^="comp-"]') ||
-        document.querySelector('[class*="wixui-footer"]') ||
-        document.querySelector('[data-mesh-id*="SITE_FOOTER"]') ||
-        document.querySelector('[id*="SITE_FOOTER"]'), false);
-    }
-    if (HIDE_ADS) {
-      hide(document.getElementById('WIX_ADS') ||
-        document.querySelector('.WIX_ADS') ||
-        document.querySelector('[class*="WIX_ADS"]'), true);
-    }
-  }
-  var scheduled = false;
-  function schedule() {
-    if (scheduled) return;
-    scheduled = true;
-    requestAnimationFrame(function(){ scheduled = false; pass(); });
-  }
-  function start() {
-    pass();
-    new MutationObserver(schedule).observe(document.documentElement, { childList: true, subtree: true });
-  }
-  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', start);
-  else start();
-})();`;
-}
 function resolveSiteChrome(chrome) {
   return {
     hideSiteHeader: chrome?.hideSiteHeader ?? true,
@@ -13084,11 +13059,15 @@ function resolveSiteChrome(chrome) {
 }
 function siteWebViewPreset(site) {
   const chrome = resolveSiteChrome(site.chrome);
-  const hidingScript = site.kind === "wix" ? siteChromeHidingScript({ hideFooter: chrome.hideSiteFooter, hideWixAds: chrome.hideWixAds }) : siteChromeHidingScript({ hideFooter: chrome.hideSiteFooter, hideWixAds: false });
-  const config = {
+  return {
     layout: "inset",
     immersive: true,
+    // Chrome hiding is binary-shipped (RFC 0062): only these flags travel over the air, so an
+    // owner can flip one without a new build, and no page script is served OTA (invariant 15).
     hideHostedSiteHeader: chrome.hideSiteHeader,
+    hideHostedSiteFooter: chrome.hideSiteFooter,
+    // Wix ads only exist on Wix free sites; a Base44 site never gets the Wix selectors.
+    hideWixAds: site.kind === "wix" && chrome.hideWixAds,
     pullToRefresh: true,
     showProgressBar: true,
     syncStatusBarAppearance: true,
@@ -13104,8 +13083,6 @@ function siteWebViewPreset(site) {
     // platforms; see SITE_SHELL_MAX_TABS for why the tab count stays within the store's cap).
     keepAlive: true
   };
-  if (hidingScript) config.injectJsDocumentEnd = hidingScript;
-  return config;
 }
 function defineSiteTab(site, page) {
   assertSitePage(page);
@@ -13285,7 +13262,6 @@ export {
   selectIdiomOverlay,
   shouldRevealError,
   siteAllowedOrigins,
-  siteChromeHidingScript,
   siteHost,
   siteNav,
   sitePageUrl,