@wix/himalaya-cli 0.1613.0 → 0.1615.0

package/templates/salon-spa/tier5-src/_shared/business-chat-message-model.ts

@@ -0,0 +1,177 @@
+/** Read-only presentation model. HTML stays text; remote actions require a separate dispatcher. */
+export type PartKind = 'text' | 'image' | 'file' | 'audio' | 'video' | 'card' | 'form' | 'system' | 'unsupported';
+export interface MessageButton { id: string; label: string; url: string; interactionId?: string; unavailableReason?: string }
+export interface PartRow {
+  id: string; kind: PartKind; text: string; url: string; fileName: string; caption: string;
+  buttons?: MessageButton[]; fields?: { name: string; value: string }[];
+  mimeType?: string; iconUrl?: string; mediaId?: string; urlExpiration?: string; unavailableReason?: string;
+  mediaProvider?: string; thumbnailUrl?: string;
+}
+export interface MessageRow {
+  id: string; sequence: string; sender: string; senderId: string; when: string; createdDate: string;
+  mine: boolean; status: string; direction: string; parts: PartRow[]; plainText: string;
+}
+type Obj = Record<string, unknown>;
+function obj(value: unknown): Obj { return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Obj : {}; }
+function str(value: unknown): string { return typeof value === 'string' ? value : typeof value === 'number' && Number.isFinite(value) ? String(value) : ''; }
+function first(...values: unknown[]): string { for (const value of values) { const s = str(value); if (s) return s; } return ''; }
+function stable(value: unknown, ancestors: unknown[] = []): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? String(value);
+  if (ancestors.includes(value)) return '[circular]';
+  const next = [...ancestors, value];
+  return Array.isArray(value) ? '[' + value.map(v => stable(v, next)).join(',') + ']' : '{' + Object.keys(value as Obj).sort().map(k => JSON.stringify(k) + ':' + stable((value as Obj)[k], next)).join(',') + '}';
+}
+function hash(value: unknown): string {
+  const text = stable(value); let a = 2166136261; let b = 5381;
+  for (let i = 0; i < text.length; i++) { a = Math.imul(a ^ text.charCodeAt(i), 16777619); b = Math.imul(b, 33) ^ text.charCodeAt(i); }
+  return (a >>> 0).toString(16).padStart(8, '0') + (b >>> 0).toString(16).padStart(8, '0');
+}
+/** HTTPS only, no credentials/control characters/backslashes. Does not depend on worker URL globals. */
+function safeUrl(value: unknown): string {
+  if (typeof value !== 'string' || /[\s\\\u0000-\u001f\u007f-\u009f]/u.test(value)) return '';
+  const match = /^https:\/\/([^/?#]+)(?:[/?#].*)?$/iu.exec(value);
+  if (!match) return '';
+  const authority = match[1];
+  if (authority.includes('@') || !/^(?:[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?|\[[0-9a-f:]+\])(?::[0-9]{1,5})?$/iu.test(authority)) return '';
+  const port = /:([0-9]+)$/.exec(authority);
+  if (port && Number(port[1]) > 65535) return '';
+  return value;
+}
+function htmlText(value: string): string {
+  // Output is plain text, never markup. No href/src extraction or HTML insertion.
+  return value.replace(/<!--[\s\S]*?-->/g, '').replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, '')
+    .replace(/<\s*br\s*\/?\s*>/gi, '\n').replace(/<\/(p|div|li|h[1-6])\s*>/gi, '\n').replace(/<[^>]*>/g, '')
+    .replace(/&(#x[0-9a-f]+|#[0-9]+|amp|lt|gt|quot|apos|nbsp);/gi, (whole, entity: string) => {
+      const names: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' };
+      if (entity[0] !== '#') return names[entity.toLowerCase()] ?? whole;
+      const n = entity[1]?.toLowerCase() === 'x' ? parseInt(entity.slice(2), 16) : Number(entity.slice(1));
+      return n > 0 && n <= 0x10ffff && !(n >= 0xd800 && n <= 0xdfff) ? String.fromCodePoint(n) : whole;
+    });
+}
+function base(id: string, kind: PartKind, text = ''): PartRow { return { id, kind, text, url: '', fileName: '', caption: '' }; }
+function unsupported(id: string, value: unknown, reason = 'Unsupported message content'): PartRow {
+  return { ...base(id, 'unsupported', typeof value === 'string' ? value : stable(value)), caption: reason, unavailableReason: reason };
+}
+function media(id: string, kind: 'image' | 'file' | 'audio' | 'video', input: unknown): PartRow {
+  const m = obj(input); const candidate = first(m.url, m.uri, m.downloadUrl, m.src, typeof input === 'string' ? input : '');
+  const url = safeUrl(candidate); const mime = first(m.mimeType, m.contentType);
+  const resolvedKind = kind === 'file' && /^audio\//i.test(mime) ? 'audio' : kind === 'file' && /^video\//i.test(mime) ? 'video' : kind;
+  const missing = url ? '' : candidate ? 'Attachment URL is unavailable: only safe HTTPS links are supported.' : 'Attachment requires a download URL.';
+  return { ...base(id, resolvedKind, first(m.text, m.title)), url, fileName: first(m.filename, m.fileName, m.name), caption: first(m.caption, m.alt, missing), mimeType: mime, mediaId: first(m.mediaFileId, m.id, m._id, m.fileId), mediaProvider: str(m.mediaProvider), thumbnailUrl: safeUrl(m.thumbnailUrl), urlExpiration: str(m.urlExpiration), ...(missing ? { unavailableReason: missing } : {}) };
+}
+function buttons(value: unknown, prefix: string): MessageButton[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((value, i) => {
+    const b = obj(value); const raw = first(b.launchUrl, b.url, b.href, obj(b.action).url); const url = safeUrl(raw);
+    const interactionId = first(obj(b.postbackProperties).interactionId, b.interactionId);
+    return { id: prefix + '-button-' + i, label: first(b.label, b.title, b.text, 'Action'), url,
+      ...(interactionId ? { interactionId } : {}),
+      ...(!url ? { unavailableReason: raw ? 'Only safe HTTPS links are supported.' : interactionId ? 'This interaction requires a supported server action.' : 'Action has no supported link.' } : {}) };
+  });
+}
+function card(id: string, input: unknown, kind: 'card' | 'form' | 'system' = 'card'): PartRow[] {
+  const c = obj(input); const lines = Array.isArray(c.textLines) ? c.textLines.map(str) : [];
+  const text = [first(c.title, c.name), first(c.text, c.description, c.body), ...lines].filter(Boolean).join('\n');
+  const fields = Array.isArray(c.fields) ? c.fields.map(f => ({ name: first(obj(f).name, obj(f).label), value: typeof obj(f).value === 'string' ? obj(f).value as string : stable(obj(f).value) })) : [];
+  const result: PartRow = { ...base(id, kind, text), buttons: buttons(c.buttons, id), ...(fields.length ? { fields } : {}) };
+  const image = first(c.imageUrl, c.iconUrl, obj(c.image).url, obj(c.image).uri);
+  if (image) { result.url = safeUrl(image); if (!result.url) result.unavailableReason = 'Card image requires a safe HTTPS URL.'; }
+  const parts = [result];
+  if (Array.isArray(c.media)) c.media.forEach((v, i) => parts.push(...basicItem(`${id}-media-${i}`, v)));
+  if (!text && !fields.length && !result.buttons?.length && !image && parts.length === 1) return [unsupported(id, input)];
+  return parts;
+}
+function basicItem(id: string, value: unknown): PartRow[] {
+  if (typeof value === 'string') return [base(id, 'text', value)];
+  const v = obj(value); const parts: PartRow[] = [];
+  if (typeof v.text === 'string') parts.push(base(id + '-text', 'text', v.text));
+  for (const kind of ['image', 'file', 'audio', 'video'] as const) if (v[kind] !== undefined && v[kind] !== null) parts.push(media(id + '-' + kind, kind, v[kind]));
+  for (const key of Object.keys(v).filter(k => !['text', 'image', 'file', 'audio', 'video', 'id', '_id', 'type'].includes(k))) parts.push(unsupported(id + '-extra-' + key, { [key]: v[key] }));
+  return parts.length ? parts : [unsupported(id, value)];
+}
+function publicParts(content: Obj, id: string): PartRow[] {
+  const parts: PartRow[] = [];
+  if (content.basic !== undefined) {
+    const items = obj(content.basic).items;
+    if (Array.isArray(items) && items.length) items.forEach((v, i) => parts.push(...basicItem(`${id}-basic-${i}`, v)));
+    else parts.push(unsupported(id + '-basic', content.basic));
+  }
+  for (const key of ['template', 'form', 'system'] as const) if (content[key] !== undefined) parts.push(...card(id + '-' + key, content[key], key === 'template' ? 'card' : key));
+  if (content.minimal !== undefined) {
+    const m = obj(content.minimal); const part = base(id + '-minimal', 'system', str(m.text)); const rawUrl = str(m.url);
+    if (rawUrl) { part.url = safeUrl(rawUrl); if (!part.url) part.unavailableReason = 'Only safe HTTPS links are supported.'; }
+    const icon = str(m.iconUrl);
+    if (icon) { part.iconUrl = safeUrl(icon); if (!part.iconUrl) part.caption = 'Activity icon requires a safe HTTPS URL.'; }
+    parts.push(part.text || part.url ? part : unsupported(part.id, content.minimal));
+  }
+  const unknown = Object.keys(content).filter(k => !['basic', 'template', 'form', 'system', 'minimal', 'title', 'previewText'].includes(k));
+  for (const key of unknown) parts.push(unsupported(id + '-content-' + key, { [key]: content[key] }));
+  return parts;
+}
+function chatPart(id: string, value: unknown): PartRow[] {
+  const v = obj(value); const mime = first(v.mimeType, v.contentType).toLowerCase().split(';')[0].trim(); const d = v.data;
+  const data = obj(d);
+  if (Array.isArray(data.cards)) return data.cards.length ? data.cards.flatMap((item, i) => card(`${id}-card-${i}`, item)) : [unsupported(id, value)];
+  if (mime === 'text/plain') return [base(id, 'text', typeof d === 'string' ? d : first(data.text, v.text))];
+  if (mime === 'text/html') return [{ ...base(id, 'text', htmlText(typeof d === 'string' ? d : first(data.html, data.text, v.text))), caption: 'HTML message shown as plain text' }];
+  // Branded chat separates the outer message-part kind from the file's MIME.
+  // mobile-apps-inbox MIME_TYPE: uri/image, uri/file; actual MIME lives in data.type.
+  if (mime === 'uri/image' || mime === 'uri/file') {
+    return [media(id, mime === 'uri/image' ? 'image' : 'file', typeof d === 'string' ? d : {
+      ...data, mimeType: first(data.type, data.mimeType, data.contentType),
+    })];
+  }
+  if (/^(image|audio|video)\//.test(mime)) {
+    const kind = mime.split('/')[0] as 'image' | 'audio' | 'video';
+    return [media(id, kind, typeof d === 'string' ? d : { ...data, mimeType: mime })];
+  }
+  if (/card|template|form|system/.test(mime)) {
+    let payload: unknown = d;
+    if (typeof payload === 'string') { try { payload = JSON.parse(payload); } catch { return [unsupported(id, payload)]; } }
+    return card(id, payload, /form/.test(mime) ? 'form' : /system/.test(mime) ? 'system' : 'card');
+  }
+  if (typeof d === 'string' && /^application\//.test(mime) && safeUrl(d)) return [media(id, 'file', { url: d, mimeType: mime })];
+  if (first(data.uri, data.url, data.downloadUrl) && (first(data.fileName, data.filename, data.name) || /^(application|text)\//.test(mime))) return [media(id, 'file', { ...data, mimeType: mime })];
+  return [unsupported(id, value, mime ? `Unsupported message part (${mime})` : 'Unsupported message part')];
+}
+function decimal(value: string): { negative: boolean; digits: string } | null {
+  if (!/^-?\d+$/.test(value)) return null;
+  const digits = value.replace(/^-/, '').replace(/^0+(?=\d)/, ''); return { negative: value[0] === '-' && digits !== '0', digits };
+}
+/** Exact decimal ordering, including int64 values beyond JavaScript's safe integer range. */
+export function compareSequence(a: string, b: string): number {
+  const x = decimal(a); const y = decimal(b);
+  if (x && y) { if (x.negative !== y.negative) return x.negative ? -1 : 1; const n = x.digits.length === y.digits.length ? x.digits < y.digits ? -1 : x.digits > y.digits ? 1 : 0 : x.digits.length < y.digits.length ? -1 : 1; return x.negative ? -n : n; }
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function dateText(raw: unknown): string {
+  if (typeof raw === 'string') return raw;
+  if (typeof raw === 'number' && Number.isFinite(raw)) { const date = new Date(raw); return Number.isFinite(date.getTime()) ? date.toISOString() : ''; }
+  return '';
+}
+function normalize(value: unknown, myMemberId?: string): MessageRow {
+  const m = obj(value); const sender = obj(m.sender); const display = obj(m.senderDisplayData);
+  const id = typeof m.id === 'string' && m.id ? m.id : typeof m._id === 'string' && m._id ? m._id : typeof m.id === 'number' && Number.isSafeInteger(m.id) ? String(m.id) : 'local-' + hash(value);
+  const senderId = first(sender.memberId, sender.userId, sender.wixUserId, sender.contactId, sender.anonymousVisitorId, m.senderId);
+  const direction = str(m.direction); const senderName = first(display.name, obj(m.senderDisplayData).displayName, sender.name, typeof m.sender === 'string' ? m.sender : '', sender.type);
+  let parts: PartRow[] = publicParts(obj(m.content), id);
+  if (Array.isArray(m.data)) m.data.forEach((v, i) => parts.push(...chatPart(`${id}-chat-${i}`, v)));
+  if (!parts.length) { // A chat-web template message (a card) keeps its visible text in the top-level templateData.
+    const body = first(m.body, m.text, obj(m.templateData).text, m.summary, obj(m.content).previewText); parts = body ? [base(id + '-text', 'text', body)] : [unsupported(id + '-unknown', m.content ?? m.data ?? { messageType: m.messageType ?? 'unknown' })]; }
+  const sequence = typeof m.sequence === 'string' ? m.sequence : typeof m.sequence === 'number' && Number.isSafeInteger(m.sequence) ? String(m.sequence) : '';
+  const createdDate = dateText(m.createdDate ?? m._createdDate ?? m.createdAt);
+  const mine = !!myMemberId && [sender.memberId, sender.userId, sender.wixUserId, sender.contactId, sender.anonymousVisitorId, m.senderId].includes(myMemberId);
+  const status = first(m.status, m.deliveryStatus, obj(m.transit).status, obj(m.transit).state, 'stored');
+  return { id, sequence, sender: senderName || (senderId ? senderId : 'Unknown sender'), senderId, when: createdDate, createdDate, mine, status, direction, parts, plainText: parts.map(p => [p.text, ...(p.fields ?? []).map(f => `${f.name}: ${f.value}`), p.fileName || p.caption].filter(Boolean).join('\n')).filter(Boolean).join('\n') };
+}
+/** Newest representation replaces the same message ID; deterministic tie ordering never uses wall clock. */
+export function mergeMessages(oldRows: MessageRow[], newRows: MessageRow[]): MessageRow[] {
+  const byId = new Map<string, MessageRow>(); for (const row of [...oldRows, ...newRows]) byId.set(row.id, row);
+  return [...byId.values()].sort((a, b) => {
+    if (!!a.sequence !== !!b.sequence) return a.sequence ? 1 : -1;
+    if (a.sequence && b.sequence) { const order = compareSequence(a.sequence, b.sequence); if (order) return order; }
+    if (a.createdDate !== b.createdDate) return a.createdDate < b.createdDate ? -1 : 1;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+}
+export function normalizeMessages(raw: unknown[], myMemberId?: string): MessageRow[] { return mergeMessages([], raw.map(value => normalize(value, myMemberId))); }

package/templates/salon-spa/tier5-src/_shared/business-chat-model.ts

@@ -0,0 +1,56 @@
+import { formatClock } from './engine-intl.js';
+import { mergeMessages, normalizeMessages, type MessageRow } from './business-chat-message-model.js';
+
+/** `delivery` is what the composer's own row shows while the server catches up: sending, accepted (shown with its
+ *  time) or unconfirmed (the request failed without a definite answer). The server names the stored message, so the
+ *  new one is recognised by its text, among the messages after `afterId` (the newest stored message on screen when it
+ *  was sent), or among all of them when the room was loaded and empty (`fromStart`); `priorCount` is how many earlier
+ *  sends with the same text were still waiting for their stored copy. `smartChatFromStart` records a successful empty
+ *  Smart Chat read before sending from Members history; it selects that anchor only for accepted delivery viewed in Smart Chat history. */
+export interface BusinessChatIntent { id:string; text:string; roomId:string; principal:string; createdDate:string; delivery:'sending'|'sent'|'unconfirmed'; senderName?:string; storedId?:string; afterId?:string; fromStart?:boolean; priorCount?:number; smartChatFromStart?:boolean }
+
+export function newBusinessChatIntent(text:string,roomId:string,principal:string,random=Math.random):BusinessChatIntent{
+ return {id:'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,c=>{const r=Math.floor(random()*16);return(c==='x'?r:(r&3)|8).toString(16);}),text,roomId,principal,createdDate:new Date().toISOString(),delivery:'sending'};
+}
+export function businessChatSendRejected(error:unknown):boolean{
+ return /\b(400|401|403|404|409|413|422|429)\b|approved first-party|webwix_owner_only|sign_in_required|owner_preview_read_only/i.test(String((error as Error)?.message||error));
+}
+export function draftAfterAcceptedSend(currentDraft:string,sentDraft:string):string{return currentDraft===sentDraft?'':currentDraft;}
+type Row={id:string;mine?:boolean;bodyText?:string;pending?:boolean};
+const sameOwnText=(message:Row,text:string)=>!!message.mine&&(message.bodyText??'').trim()===text.trim();
+/** What a send records about the screen it was sent from: the newest stored message (history is one page in time
+ *  order, so counting only after it ignores old messages, even one that drops off the page), and how many sends with
+ *  the same words are still waiting for their stored copies. No clock is involved: the phone's and the server's differ. */
+export function sendAnchor(messages:Row[],text:string,roomLoaded:boolean):{afterId?:string;fromStart?:boolean;priorCount:number}{
+ const stored=messages.filter(message=>!message.pending);
+ const priorCount=messages.filter(message=>message.pending&&sameOwnText(message,text)).length;
+ // A room that loaded with nothing in it: every stored message that appears later is newer than this send's screen.
+ // One that failed to load has no anchor at all, as it may hold older messages with the same words.
+ if(!stored.length)return roomLoaded?{fromStart:true,priorCount}:{priorCount};
+ return {afterId:stored[stored.length-1]!.id,priorCount};
+}
+/** Whether history already holds the member's sent message: by its own id, or as one more message of theirs with the
+ *  same text than there were when it was sent (the Smart Chat send does not let the app choose the stored id). This
+ *  only places the message on screen: the send itself is settled by its own request, never by what history shows, so
+ *  a coincidence (the same words sent from the website meanwhile) cannot hide a failure. */
+export function pendingIntentWasObserved(messages:Row[],intent:BusinessChatIntent|null):boolean{
+ if(!intent)return false;
+ const stored=messages.filter(message=>!message.pending);
+ if(stored.some(message=>message.id===(intent.storedId||intent.id)))return true;
+ let newer:Row[];
+ if(intent.fromStart)newer=stored;
+ else{
+  // With no anchor (the room had not loaded) or the anchor gone, an older message with these words cannot be told apart.
+  const after=intent.afterId?stored.findIndex(message=>message.id===intent.afterId):-1;
+  if(after<0)return false;
+  newer=stored.slice(after+1);
+ }
+ return newer.filter(message=>sameOwnText(message,intent.text)).length>(intent.priorCount??0);
+}
+export function messageTimeLabel(value:string):string{
+ const date=new Date(value);
+ return Number.isFinite(date.getTime())?formatClock(date):'';
+}
+export function chronologicalMessages(existing:MessageRow[],raw:unknown[],memberId?:string):MessageRow[]{
+ return mergeMessages(existing,normalizeMessages(raw,memberId)).map(row=>({...row,when:messageTimeLabel(row.createdDate),side:row.mine?'mine':'other'}));
+}