@namiml/expo-sdk 3.4.0-dev.202605060437

package/src/utils/impression.ts

@@ -0,0 +1,39 @@
+import {
+  getUrlParams,
+  Impression,
+  isAnonymousMode,
+  logger,
+  NamiAPI,
+  storageService,
+} from '@namiml/sdk-core';
+
+function buildImpressionPayload(impression: Impression): Impression {
+  const payload: Impression = { ...impression };
+  const sessionId = storageService.getSessionId();
+  if (sessionId) {
+    payload.session = sessionId;
+  }
+
+  const launchId = storageService.getLaunchId();
+  if (launchId) {
+    payload.launch_id = launchId;
+  }
+
+  payload.app_env = NAMI_SDK_ENV;
+  payload.url_params = getUrlParams();
+  return payload;
+}
+
+export const postImpression = async (impression: Impression): Promise<void> => {
+  if (isAnonymousMode()) {
+    return;
+  }
+
+  const payload = buildImpressionPayload(impression);
+
+  try {
+    await NamiAPI.instance.postImpression(payload);
+  } catch (error) {
+    logger.error('Error posting impression', error);
+  }
+};

package/src/utils/rendering.ts

@@ -0,0 +1,197 @@
+import {
+  LIQUID_VARIABLE_REGEX,
+  SMART_TEXT_PATTERN,
+  type TComponent,
+} from '@namiml/sdk-core';
+import { buildSmartTextReplacements, interpolate, interpolateSmartText } from './smartText';
+
+const DEEP_SMART_TEXT_PRESERVE_KEYS = new Set([
+  'components',
+  'productBaseComponents',
+  'productFeaturedComponents',
+  'collapseHeader',
+]);
+
+function componentSmartTextSku(component: any): any {
+  return component?.smartTextSku ?? component?.sku;
+}
+
+export function conditionComponentMatches(
+  ctx: any,
+  condition: any,
+  sku: any = componentSmartTextSku(condition),
+): boolean {
+  if (condition.assertions) {
+    return condition.assertions.every((test: any) => testObjectMatches(ctx, test, undefined, sku));
+  }
+  if (condition.orAssertions) {
+    return !condition.orAssertions.length || condition.orAssertions.some((test: any) => testObjectMatches(ctx, test, undefined, sku));
+  }
+  return false;
+}
+
+export function withOverrides<T extends Record<string, any>>(
+  ctx: any,
+  { conditionAttributes, ...component }: T,
+  sku: any = componentSmartTextSku(component),
+): T {
+  if (!conditionAttributes) return component as T;
+  return conditionAttributes.reduce((nextComponent: T, condition: any): T => {
+    if (!conditionComponentMatches(ctx, condition, sku)) return nextComponent;
+    const resolvedAttributes = Object.fromEntries(
+      Object.entries(condition.attributes ?? {}).map(([key, value]) => [
+        key,
+        valueFromSmartText(ctx, value, sku),
+      ]),
+    );
+    return { ...nextComponent, ...resolvedAttributes };
+  }, component as T);
+}
+
+export function valueFromSmartText(ctx: any, value: any, sku?: any, block: any = null): any {
+  const replacements = buildSmartTextReplacements(
+    ctx.state,
+    ctx.flow,
+    sku ?? ctx.state?.sku,
+    block,
+  );
+  if (typeof value === 'string' && value.includes(SMART_TEXT_PATTERN)) {
+    return interpolateSmartText(value, replacements);
+  }
+  return value;
+}
+
+export function resolveComponentSmartText(component: any, ctx: any): any {
+  const smartTextSku = componentSmartTextSku(component);
+  const replacements = buildSmartTextReplacements(ctx.state, ctx.flow, smartTextSku);
+  const preservedEntries: Array<[string, any]> = [];
+  const shallowComponent = Object.entries(component ?? {}).reduce((output, [key, value]) => {
+    if (DEEP_SMART_TEXT_PRESERVE_KEYS.has(key)) {
+      // Child component trees need to keep their original template strings so they can
+      // be resolved later with their own component/SKU context.
+      preservedEntries.push([key, value]);
+      return output;
+    }
+    output[key] = valueFromSmartText(ctx, value, smartTextSku);
+    return output;
+  }, {} as Record<string, any>);
+
+  const resolvedComponent = interpolate(shallowComponent, replacements);
+  preservedEntries.forEach(([key, value]) => {
+    resolvedComponent[key] = value;
+  });
+  return resolvedComponent;
+}
+
+export function expandRenderableComponents(
+  ctx: any,
+  components: TComponent[] | undefined,
+): TComponent[] {
+  return (components ?? []).flatMap((component) =>
+    expandRenderableComponent(ctx, component as TComponent),
+  );
+}
+
+function expandRenderableComponent(ctx: any, component: TComponent | undefined): TComponent[] {
+  if (!component || (component as any).hidden) {
+    return [];
+  }
+
+  const smartTextSku = componentSmartTextSku(component);
+
+  if ((component as any).component === 'condition') {
+    if (!conditionComponentMatches(ctx, component, smartTextSku)) {
+      return [];
+    }
+
+    return expandRenderableComponents(ctx, (component as any).components);
+  }
+
+  let resolvedComponent: any = component;
+  if ((component as any).conditionAttributes?.length) {
+    resolvedComponent = withOverrides(ctx, resolvedComponent, smartTextSku);
+  }
+  resolvedComponent = resolveComponentSmartText(resolvedComponent, ctx);
+
+  return resolvedComponent?.hidden ? [] : [resolvedComponent as TComponent];
+}
+
+export function getRepeatingListBlocks(ctx: any, component: any): TComponent[][] {
+  if (!component.loopSource) {
+    return [];
+  }
+
+  const source = typeof component.loopSource === 'string'
+    ? JSON.parse(component.loopSource)
+    : component.loopSource;
+
+  return (source ?? [])
+    .map((block: any) => {
+      const matchesConditions =
+        !component.loopSourceConditions?.length ||
+        component.loopSourceConditions.every((value: any) =>
+          testObjectMatches(ctx, value, block),
+        );
+      if (!matchesConditions) {
+        return undefined;
+      }
+      return interpolate(component.components, interpolate({ block }, { block }));
+    })
+    .filter((item: TComponent[] | undefined) => item != null);
+}
+
+function testObjectMatches(
+  ctx: any,
+  { value: rawValue, expected, operator }: { value: any; expected: any; operator: string },
+  block?: any,
+  sku?: any,
+): boolean {
+  let value = valueFromSmartText(ctx, rawValue, sku, block);
+  expected = valueFromSmartText(ctx, expected, sku, block);
+
+  if (operator === 'equals') return value === expected;
+  if (operator === 'notEquals') return value !== expected;
+  if (operator === 'contains') {
+    if (typeof rawValue === 'string' && rawValue.includes('launch.productGroups')) {
+      const launchGroups = ctx?.state?.launch?.productGroups;
+      const fallbackGroups = Array.isArray(ctx?.state?.groups)
+        ? ctx.state.groups.map((group: any) => group?.ref).filter(Boolean)
+        : [];
+      const unresolvedValue =
+        value == null
+        || value === ''
+        || value === rawValue
+        || (Array.isArray(value) && value.length === 0);
+      if (unresolvedValue) {
+        value = Array.isArray(launchGroups) && launchGroups.length ? launchGroups : fallbackGroups;
+      }
+    }
+    if (!Array.isArray(value) && typeof value !== 'string' && !(value instanceof String)) {
+      value = value?.toString?.();
+    }
+    if (expected === 'collapse') {
+      expected += `_${ctx.getCurrentCollapsibleSku?.()?.skuId ?? ''}`;
+    }
+    return value?.includes?.(expected);
+  }
+  if (operator === 'notContains') {
+    if (!Array.isArray(value) && typeof value !== 'string' && !(value instanceof String)) {
+      value = value?.toString?.();
+    }
+    return !value?.includes?.(expected);
+  }
+  if (operator === 'set') {
+    if (typeof expected === 'boolean') {
+      return !!value && (!(value.toString().match(LIQUID_VARIABLE_REGEX)) === expected);
+    }
+    return !!value && !value.toString().match(LIQUID_VARIABLE_REGEX);
+  }
+  if (operator === 'notSet') {
+    return !value || !!value.toString().match(LIQUID_VARIABLE_REGEX);
+  }
+  if (operator === 'gt') return value > expected;
+  if (operator === 'gte') return value >= expected;
+  if (operator === 'lt') return value < expected;
+  if (operator === 'lte') return value <= expected;
+  return false;
+}

package/src/utils/smartText.ts

@@ -0,0 +1,148 @@
+import type { NamiFlow, TPaywallContext } from '@namiml/sdk-core';
+import { getUrlParams, SMART_TEXT_PATTERN, VAR_REGEX } from '@namiml/sdk-core';
+
+type ReplacementsType = Record<string, any>;
+
+export type SmartTextFlowState = {
+  isLaunched: boolean;
+  previousStepAvailable: boolean;
+  nextStepAvailable: boolean;
+};
+
+export type SmartTextReplacements = {
+  state: TPaywallContext;
+  urlParams: Record<string, any>;
+  flow: SmartTextFlowState;
+  launch: TPaywallContext['launch'];
+  sku: any;
+  customer: TPaywallContext['customer'];
+  block?: any;
+};
+
+function getAttr(object: any, ...attrs: Array<string | number>): any {
+  let current = object;
+  for (const attr of attrs) {
+    if (current === undefined || current === null) return undefined;
+    current = Array.isArray(current) ? current[+attr] : current[attr];
+  }
+  return current;
+}
+
+function interpolateString(value: string, replacements: ReplacementsType): any {
+  let output = value;
+  if (typeof value !== 'string') {
+    return output;
+  }
+  if (!value.includes('$')) {
+    return value;
+  }
+
+  const regex = new RegExp(VAR_REGEX.source, VAR_REGEX.flags);
+  const matches: RegExpExecArray[] = [];
+  let matchResult: RegExpExecArray | null;
+  while ((matchResult = regex.exec(value)) !== null) {
+    matches.push(matchResult);
+    if (!regex.global) break;
+    if (matchResult.index === regex.lastIndex) regex.lastIndex++;
+  }
+
+  for (const [match, rawPath] of matches) {
+    const path = interpolateString(rawPath, replacements);
+    if (match === value) return replacer(match, path);
+    if (path !== rawPath) {
+      output = output.replace(rawPath, path);
+    }
+    output = output.replace(VAR_REGEX, replacer as any);
+  }
+  return output;
+
+  function replacer(matchValue: string, pathValue: string): string {
+    const pathParts = String(pathValue).split('.');
+    const firstKey = pathParts[0];
+    if (!firstKey) return matchValue;
+
+    const firstSegment = getAttr(replacements, firstKey);
+    if (firstSegment === undefined) return matchValue;
+
+    const isEmptyObject =
+      typeof firstSegment === 'object'
+      && firstSegment !== null
+      && Object.keys(firstSegment).length === 0;
+    if (isEmptyObject) return '';
+
+    const newValue = getAttr(replacements, ...pathParts);
+    if (newValue === undefined) return '';
+    if (typeof newValue !== 'string') return newValue as unknown as string;
+    return interpolateString(newValue, replacements);
+  }
+}
+
+export function interpolate<T>(value: T, replacements: ReplacementsType): T {
+  if (Array.isArray(value)) {
+    const output: any[] = [];
+    for (const item of value) {
+      const newValue = interpolate(item, replacements);
+      if (Array.isArray(newValue)) {
+        output.push(...newValue);
+      } else {
+        output.push(newValue);
+      }
+    }
+    return output as unknown as T;
+  }
+
+  if (value === null || value === undefined) return value;
+
+  if (typeof value === 'object') {
+    const output: Record<string, any> = {};
+    for (const [key, current] of Object.entries(value as Record<string, any>)) {
+      output[key] = key === 'newRow' ? current : interpolate(current, replacements);
+    }
+    return output as T;
+  }
+
+  if (typeof value === 'string') return interpolateString(value, replacements);
+  return value;
+}
+
+export function buildSmartTextReplacements(
+  state: TPaywallContext,
+  flow?: NamiFlow,
+  sku?: any,
+  block?: any,
+): SmartTextReplacements {
+  return {
+    state,
+    urlParams: getUrlParams(),
+    flow: {
+      isLaunched: !!flow?.manager?.flowOpen,
+      previousStepAvailable: !!flow?.previousStepAvailable,
+      nextStepAvailable: !!flow?.nextStepAvailable,
+    },
+    launch: state.launch,
+    sku: sku ?? state.sku,
+    customer: state.customer,
+    block,
+  };
+}
+
+export function resolveSmartText(text: string | undefined, state: TPaywallContext): string {
+  if (!text) return '';
+  return String(interpolateSmartText(text, buildSmartTextReplacements(state)) ?? '');
+}
+
+export function interpolateSmartText(value: any, replacements: SmartTextReplacements): any {
+  if (value == null) return value;
+  if (typeof value !== 'string') return value;
+  if (!value.includes(SMART_TEXT_PATTERN)) return value;
+  return interpolateString(value, replacements);
+}
+
+export function interpolateComponent<T extends Record<string, any>>(
+  component: T,
+  state: TPaywallContext,
+  skuVars?: Record<string, any>,
+): T {
+  const replacements = buildSmartTextReplacements(state, undefined, skuVars);
+  return interpolate(component, replacements);
+}