@wix/himalaya-cli 0.1154.0 → 0.1156.0

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

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { DerivedAppMeta } from "./app-module.js";
 import { type WixCachePolicy } from "./wix-cache-policy.js";
 import type { WixMockRule } from "./wix-gateway.js";
+import { type UnmappedPushDestination } from "../../ts/src/wix-push-links.js";
 import type { PushConfig, FlagConfig, AppControl, TabBarConfig, DrawerConfig, SidebarConfig, SplashConfig, LocaleConfig, NavKind, OrientationConfig, StreamPolicy } from "@wix/himalaya/core";
 export type { PushConfig, FlagConfig, AppControl, TabBarConfig, DrawerConfig, SidebarConfig, SplashConfig, LocaleConfig, NavKind, OrientationConfig, StreamPolicy };
 export interface DeepLinkPattern {
@@ -214,6 +215,21 @@ export interface NavBundleContext {
     serverBaseUrl: string;
     bundleIntegrity(bundleName: string): string | null;
 }
+/** The push block an app serves, and what a derived route table could not cover. */
+export interface ServedPush {
+    push?: import("@wix/himalaya/core").PushConfig;
+    /** True when `routes` were derived rather than authored. */
+    derived: boolean;
+    unmapped: UnmappedPushDestination[];
+}
+/**
+ * The app's push block with its notification routes filled in, when the author opted into Wix
+ * push (`payloadAdapter: "wix-ping"`), wrote no `routes` of their own, and the package records its
+ * site's verticals (`derivesWixPushRoutes`). Routes then come from those verticals and the screens the router can open,
+ * so a build after adding a screen picks it up with no other step. Authored routes — an empty
+ * list included — are the author's, and are served untouched.
+ */
+export declare function derivePushForApp(app: DerivedAppMeta, linkableScreens?: readonly LinkableScreen[]): ServedPush;
 export declare function deriveNavigationConfig(app: DerivedAppMeta, bundleCtx?: NavBundleContext): NavigationConfig;
 export interface AppConfigDocument {
     config: NavigationConfig;

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

@@ -1,4 +1,4 @@
-import type { AppConfig, AppConfigLike, FunctionsAppConfig } from "@wix/himalaya/core";
+import type { AppConfig, AppConfigLike, FunctionsAppConfig, PushConfig } from "@wix/himalaya/core";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { ActionHandler } from "./actions/types.js";
 import type { ScreenDescriptor } from "./builder.js";
@@ -175,8 +175,15 @@ export interface DerivedAppMeta {
     urlScheme: string;
     /** Forwarded from AppConfig.cache: the app's declared Wix read cache rules (#3450 follow-up). */
     cache?: import("@wix/himalaya/core").AppCacheConfig;
-    /** Forwarded from AppConfig.push for the OTA app-config channel. */
+    /** Forwarded from AppConfig.push for the OTA app-config channel, minus the authoring-only
+     *  `screens` map, which is carried separately below and never served. */
     push?: import("@wix/himalaya/core").PushConfig;
+    /** AppConfig.push.screens — which screen each Wix notification destination opens, for the
+     *  routes `deriveNavigationConfig` derives when the app wrote none. */
+    pushScreens?: PushConfig["screens"];
+    /** `provisioning.json` `installedVerticals` — the site's verticals, which decide which Wix
+     *  notification destinations a derived route table covers. Read from disk at load time. */
+    installedVerticals?: string[];
     /** Forwarded from AppConfig.control for the OTA app-config channel. */
     control?: import("@wix/himalaya/core").AppControl;
     /** Forwarded from AppConfig.appLinkHosts for the OTA app-config channel. */
@@ -270,7 +277,8 @@ export interface DerivedAppMeta {
     /** Android App-Links identity for /.well-known/assetlinks.json. */
     androidAssetLinks?: import("@wix/himalaya/core").AndroidAssetLinks;
 }
-/** `platforms` is the app's parsed `platforms.json` (RFC 0051 surface envelope).
- *  Passed IN rather than read here because this module is types-only by design —
- *  the reader lives in loader.ts, which already touches the filesystem. */
-export declare function deriveAppMeta(name: string, m: AppDevModule, platforms?: Record<string, boolean>): DerivedAppMeta;
+/** `platforms` is the app's parsed `platforms.json` (RFC 0051 surface envelope), and
+ *  `provisioning` the facts read from its `provisioning.json`. Both are passed IN rather than
+ *  read here because this module is types-only by design — the readers live in loader.ts and
+ *  provisioning-facts.ts, which already touch the filesystem. */
+export declare function deriveAppMeta(name: string, m: AppDevModule, platforms?: Record<string, boolean>, provisioning?: import("./provisioning-facts.js").ProvisioningFacts): DerivedAppMeta;

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

@@ -0,0 +1,7 @@
+export interface ProvisioningFacts {
+    siteId?: string;
+    installedVerticals?: string[];
+}
+/** `<dir>/provisioning.json`'s site and verticals. A missing or unreadable file, or a field of
+ *  the wrong type, reads as absent: the file is a build input, never a reason to fail one. */
+export declare function readProvisioningFacts(dir: string): ProvisioningFacts;

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

@@ -1,5 +1,6 @@
 import type { DesignTokens } from "./tokens.js";
 import type { PushRoute, PushPayloadAdapter } from "./push-routes.js";
+import type { PushScreenMapEntry } from "./wix-push-links.js";
 import type { NavigationConfig, SplashConfig } from "./schema.js";
 import { type LocaleConfig } from "./locale.js";
 import { type DistributionConfig } from "./distribution.js";
@@ -7,7 +8,7 @@ import type { CmsConfig } from "./cms.js";
 import { type DataResourcesConfig } from "@wix/himalaya/data-resources";
 import type { FunctionDefinition, FunctionScheduleRecord } from "@himalaya/functions";
 export type { CmsConfig, CmsCollectionSpec, CmsFieldSpec, WixFieldType } from "./cms.js";
-export type { PushRoute, PushPayloadAdapter };
+export type { PushRoute, PushPayloadAdapter, PushScreenMapEntry };
 export type { DataResourcesConfig, KvSpec, ResourceEnvironment, ResourceScope } from "@wix/himalaya/data-resources";
 export { WIX_FIELD_TYPES } from "./cms.js";
 /** Wix site/environment binding used by the server-function surface. */
@@ -530,6 +531,12 @@ export interface PushConfig {
      *  hand-listing them, so a route can never target a screen the provisioned app
      *  does not have. Honoured by iOS + Android; the web host has no push transport. */
     routes?: PushRoute[];
+    /** Authoring-only: which screen each Wix notification destination opens, keyed by
+     *  destination id (`{ "store.order": "my_order" }`), when it is not the canonical one.
+     *  With `payloadAdapter: "wix-ping"` and no `routes`, every build expands this — together
+     *  with the site's `provisioning.json` verticals and the app's linkable screens — into
+     *  `routes`. Never served; `himi validate` lists the destinations still unrouted. */
+    screens?: Record<string, PushScreenMapEntry>;
     payloadAdapter?: PushPayloadAdapter;
     /** A `tier5.<service>.<action>` dispatched on EVERY notification — receipt or tap
      *  — so a worker can keep a badge count or refresh a feed without navigating. It

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

@@ -0,0 +1,81 @@
+import type { PushRoute } from "./push-routes.js";
+/**
+ * The Ping app family a customer app's members register under. Ping treats it exactly as
+ * `WixBrandedLite`: member recipients, the site's own credentials by `filterForMetaSite`,
+ * the BRANDED link format. One constant, so a revert is a one-line change.
+ */
+export declare const DEFAULT_PING_APP_NAME = "WixBrandedWebApp";
+/** One place a member notification can open, and every Wix link shape that names it. */
+export interface WixPushDestination {
+    /** `<vertical>.<thing>`, the key an author uses in `push.screens`. */
+    id: string;
+    /** The vertical `himi site analyze` writes into `provisioning.json` `installedVerticals`. */
+    vertical: string;
+    /** Owner (`wixUser`) links live in a different Ping recipient space; none are listed yet. */
+    audience: "member";
+    /** Longest first, which is the order routes are tried in. */
+    matches: readonly string[];
+    /** The capture that names the item, filled into the screen's param. Absent ⇒ the
+     *  destination is a list screen and the link carries no param. */
+    screenParam?: string;
+    /** The branded-lite screen id, which template-derived apps share. */
+    canonicalScreen: string;
+}
+export declare const WIX_MEMBER_PUSH_DESTINATIONS: readonly WixPushDestination[];
+/** `push.screens` value: the screen a destination opens, optionally with the param it reads. */
+export type PushScreenMapEntry = string | {
+    screenId: string;
+    paramKey?: string;
+};
+/** A screen a route may target — the shape of a served `LinkableScreen`, loosely. */
+export interface PushTargetScreen {
+    screenId: string;
+    paramKeys?: readonly string[];
+}
+export interface UnmappedPushDestination {
+    destination: string;
+    vertical: string;
+    /** `no_screen`: nothing the app can open. `screen_lacks_param`: a detail screen that
+     *  declares no param key the item id can go in. `param_not_declared`: `push.screens` names a
+     *  `paramKey` the screen does not declare. */
+    reason: "no_screen" | "screen_lacks_param" | "param_not_declared";
+    /** The screen that was considered, when there was one. */
+    screenId?: string;
+    /** The undeclared key, for `param_not_declared`. */
+    paramKey?: string;
+}
+export interface DerivedWixPushRoutes {
+    routes: PushRoute[];
+    unmapped: UnmappedPushDestination[];
+}
+/**
+ * Whether a build derives `routes` for this push block: the author opted into Wix links
+ * (`payloadAdapter: "wix-ping"`), declared no table of their own, and the package records its
+ * site's verticals in provisioning.json — an empty list included, since a screen the app has is
+ * routed whatever the verticals say. The build and `himi validate` both ask this, so they agree.
+ */
+export declare function derivesWixPushRoutes(push: {
+    payloadAdapter?: string;
+    routes?: unknown;
+} | undefined, installedVerticals: readonly string[] | undefined): boolean;
+/** The routes for one destination, opening `screenId` and putting the item id in `paramKey`. */
+export declare function wixPushRoutesTo(destination: WixPushDestination, target: {
+    scheme: string;
+    screenId: string;
+    paramKey?: string;
+}): PushRoute[];
+/**
+ * The routes an app's screens support, and every destination its site has that the app cannot
+ * honour yet. A destination is routed only when its screen is CERTAIN — named in `map`, or the
+ * canonical id is one the app has — because a wrong screen is worse than none.
+ *
+ * The site's verticals, and the author's own `map` entries, decide only what is reported missing.
+ * A screen that is there is routed whatever the verticals say: `himi site analyze` cannot detect every vertical (it has no probe for
+ * notifications or galleries), and a route to a screen the app has can never open the wrong one.
+ */
+export declare function deriveWixPushRoutes(input: {
+    verticals: readonly string[];
+    scheme: string;
+    screens: readonly PushTargetScreen[];
+    map?: Readonly<Record<string, PushScreenMapEntry>>;
+}): DerivedWixPushRoutes;

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

@@ -7909,10 +7909,52 @@ function walk(node, registry, path, out) {
       });
     }
   }
+  const type = typeof obj.type === "string" ? obj.type : "";
+  const colorProps = Object.prototype.hasOwnProperty.call(COLOR_TOKEN_PROPS, type) ? COLOR_TOKEN_PROPS[type] : void 0;
+  const typoProps = Object.prototype.hasOwnProperty.call(TYPOGRAPHY_TOKEN_PROPS, type) ? TYPOGRAPHY_TOKEN_PROPS[type] : void 0;
+  if ((colorProps || typoProps) && obj.props && typeof obj.props === "object") {
+    const props = obj.props;
+    const check = (spec, kind) => {
+      const [arrayKey, leaf] = spec.includes("[].") ? spec.split("[].") : [void 0, spec];
+      const sites = arrayKey ? (Array.isArray(props[arrayKey]) ? props[arrayKey] : []).map((el, i) => [`${path}.props.${arrayKey}[${i}].${leaf}`, el && typeof el === "object" ? el[leaf] : void 0]) : [[`${path}.props.${leaf}`, props[leaf]]];
+      for (const [at, v] of sites) {
+        if (typeof v !== "string" || v === "") continue;
+        if (kind === "color" ? !v.startsWith("#") && !registry.colors.has(v) : !registry.typography.has(v)) {
+          out.push({ path: at, kind, name: v });
+        }
+      }
+    };
+    for (const spec of colorProps ?? []) check(spec, "color");
+    for (const spec of typoProps ?? []) check(spec, "typography");
+  }
   for (const [key, value] of Object.entries(obj)) {
     walk(value, registry, `${path}.${key}`, out);
   }
 }
+var COLOR_TOKEN_PROPS = {
+  Badge: ["token"],
+  Card: ["background"],
+  Image: ["tint", "placeholder"],
+  Tag: ["token"],
+  Icon: ["tint"],
+  Toggle: ["trackOn", "trackOff", "thumb"],
+  ProgressBar: ["tint", "trackColor"],
+  ListItem: ["titleColor", "subtitleColor", "overlineColor"],
+  Slider: ["tint"],
+  ActivityIndicator: ["tint"],
+  Label: ["color"],
+  Gauge: ["tint", "rings[].tint"],
+  Rating: ["color"],
+  VoiceNote: ["tint"],
+  Marquee: ["color"],
+  Fab: ["tint"]
+};
+var TYPOGRAPHY_TOKEN_PROPS = {
+  ListItem: ["titleStyle", "subtitleStyle"],
+  RichText: ["runs[].style"],
+  Label: ["style"],
+  Marquee: ["style"]
+};
 
 // ../../core/ts/src/widget-vocabulary.ts
 var WIDGET_FAMILIES = ["ios_home", "ios_lock", "android_home", "web_card", "ios_live_activity", "watch_complication", "car_list"];

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

@@ -9050,7 +9050,7 @@ function isFunctionsOnlyConfig(config) {
 function uiConfig(config) {
   return config ?? {};
 }
-function deriveAppMeta(name, m, platforms = {}) {
+function deriveAppMeta(name, m, platforms = {}, provisioning = {}) {
   const config = m.config;
   return {
     surfaces: config.navigation?.surfaces,
@@ -9061,7 +9061,9 @@ function deriveAppMeta(name, m, platforms = {}) {
     screenIds: Object.keys(m.screens.exact),
     templatedPatterns: (m.screens.templated ?? []).map((t) => t.display),
     urlScheme: m.urlScheme ?? config.navigation?.scheme ?? `himalaya-${name}`,
-    push: config.push,
+    push: servedPush(config.push),
+    ...config.push?.screens ? { pushScreens: config.push.screens } : {},
+    ...provisioning.installedVerticals ? { installedVerticals: provisioning.installedVerticals } : {},
     control: config.control,
     appLinkHosts: config.appLinkHosts,
     tabBar: config.navigation?.tabBar,
@@ -9095,6 +9097,11 @@ function deriveAppMeta(name, m, platforms = {}) {
     androidAssetLinks: config.androidAssetLinks
   };
 }
+function servedPush(push) {
+  if (!push) return void 0;
+  const { screens: _authoringOnly, ...served } = push;
+  return served;
+}
 
 // ../../core/sdui/src/screen-kit.ts
 function skRect(height, id) {