@akinon/pz-theme 2.0.0-beta.21

package/src/utils/page-context-discovery.ts

@@ -0,0 +1,119 @@
+type DiscoveryValueType =
+  | 'string'
+  | 'number'
+  | 'boolean'
+  | 'null'
+  | 'object'
+  | 'array';
+
+export interface PageContextDiscoveryEntry {
+  path: string;
+  kind: 'scalar' | 'array';
+  valueType: DiscoveryValueType;
+  sample?: string;
+}
+
+export interface PageContextDiscovery {
+  roots: string[];
+  entries: PageContextDiscoveryEntry[];
+}
+
+const MAX_DISCOVERY_ENTRIES = 250;
+const MAX_SAMPLE_LENGTH = 60;
+
+const getValueType = (value: unknown): DiscoveryValueType => {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'array';
+  if (typeof value === 'string') return 'string';
+  if (typeof value === 'number') return 'number';
+  if (typeof value === 'boolean') return 'boolean';
+  return 'object';
+};
+
+const formatSample = (value: unknown) => {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  if (Array.isArray(value)) {
+    return `${value.length} item${value.length === 1 ? '' : 's'}`;
+  }
+
+  if (typeof value === 'object') {
+    return `${Object.keys(value as Record<string, unknown>).length} field${
+      Object.keys(value as Record<string, unknown>).length === 1 ? '' : 's'
+    }`;
+  }
+
+  const stringValue = String(value);
+  return stringValue.length > MAX_SAMPLE_LENGTH
+    ? `${stringValue.slice(0, MAX_SAMPLE_LENGTH - 3)}...`
+    : stringValue;
+};
+
+export const createPageContextDiscovery = (
+  input?: Record<string, unknown> | null
+): PageContextDiscovery => {
+  if (!input) {
+    return {
+      roots: [],
+      entries: []
+    };
+  }
+
+  const entries: PageContextDiscoveryEntry[] = [];
+  const seen = new Set<string>();
+
+  const pushEntry = (entry: PageContextDiscoveryEntry) => {
+    if (!entry.path || seen.has(entry.path) || entries.length >= MAX_DISCOVERY_ENTRIES) {
+      return;
+    }
+
+    seen.add(entry.path);
+    entries.push(entry);
+  };
+
+  const walk = (value: unknown, path: string) => {
+    if (!path || entries.length >= MAX_DISCOVERY_ENTRIES) {
+      return;
+    }
+
+    if (Array.isArray(value)) {
+      pushEntry({
+        path,
+        kind: 'array',
+        valueType: 'array',
+        sample: formatSample(value)
+      });
+
+      if (value.length > 0) {
+        walk(value[0], `${path}[]`);
+      }
+      return;
+    }
+
+    if (value && typeof value === 'object') {
+      Object.entries(value as Record<string, unknown>).forEach(([key, child]) => {
+        const nextPath = path ? `${path}.${key}` : key;
+        walk(child, nextPath);
+      });
+      return;
+    }
+
+    pushEntry({
+      path,
+      kind: 'scalar',
+      valueType: getValueType(value),
+      sample: formatSample(value)
+    });
+  };
+
+  Object.entries(input).forEach(([rootKey, value]) => {
+    walk(value, rootKey);
+  });
+
+  return {
+    roots: Object.keys(input),
+    entries
+  };
+};

package/src/utils/publish-window.ts

@@ -0,0 +1,86 @@
+export interface PublishWindowValue {
+  enabled?: boolean;
+  startAt?: string;
+  endAt?: string;
+}
+
+export type PublishWindowStatus =
+  | 'inactive'
+  | 'scheduled'
+  | 'active'
+  | 'expired';
+
+const isPublishWindowShape = (value: unknown): value is PublishWindowValue => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+
+  const candidate = value as Record<string, unknown>;
+  return (
+    candidate.enabled !== undefined ||
+    candidate.startAt !== undefined ||
+    candidate.endAt !== undefined
+  );
+};
+
+export const normalizePublishWindowValue = (
+  value: unknown
+): PublishWindowValue => {
+  if (isPublishWindowShape(value)) {
+    return {
+      enabled: value.enabled === true,
+      startAt: typeof value.startAt === 'string' ? value.startAt : '',
+      endAt: typeof value.endAt === 'string' ? value.endAt : ''
+    };
+  }
+
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    const responsiveValue = value as Record<string, unknown>;
+    const nestedValue =
+      responsiveValue.desktop ||
+      responsiveValue.mobile ||
+      responsiveValue.tablet;
+
+    if (nestedValue && nestedValue !== value) {
+      return normalizePublishWindowValue(nestedValue);
+    }
+  }
+
+  return {
+    enabled: false,
+    startAt: '',
+    endAt: ''
+  };
+};
+
+const parsePublishTime = (value?: string): number | null => {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+
+export const getPublishWindowStatus = (
+  value: unknown,
+  now: Date = new Date()
+): PublishWindowStatus => {
+  const publishWindow = normalizePublishWindowValue(value);
+
+  if (!publishWindow.enabled) return 'inactive';
+
+  const currentTime = now.getTime();
+  const startAt = parsePublishTime(publishWindow.startAt);
+  const endAt = parsePublishTime(publishWindow.endAt);
+
+  if (startAt !== null && currentTime < startAt) return 'scheduled';
+  if (endAt !== null && currentTime > endAt) return 'expired';
+
+  return 'active';
+};
+
+export const isPublishWindowVisible = (
+  value: unknown,
+  now: Date = new Date()
+): boolean => {
+  const status = getPublishWindowStatus(value, now);
+  return status === 'inactive' || status === 'active';
+};

package/src/utils/visibility-rules.ts

@@ -0,0 +1,188 @@
+import { Block } from '../theme-block';
+import { Section } from '../theme-section';
+
+export type VisibilityAuthState = 'all' | 'authenticated' | 'guest';
+export type VisibilityPathMatchType =
+  | 'any'
+  | 'equals'
+  | 'contains'
+  | 'startsWith';
+
+export interface VisibilityRules {
+  enabled?: boolean;
+  authState?: VisibilityAuthState;
+  allowedBreakpoints?: string[];
+  allowedLocales?: string[];
+  allowedCurrencies?: string[];
+  pathnameMatchType?: VisibilityPathMatchType;
+  pathnameValue?: string;
+  queryParamKey?: string;
+  queryParamValue?: string;
+}
+
+export interface VisibilityRuleContext {
+  authState: 'authenticated' | 'guest' | 'loading';
+  breakpoint: string;
+  locale: string;
+  currency: string;
+  pathname: string;
+  searchParams?: {
+    get: (key: string) => string | null;
+  } | null;
+}
+
+const normalizeStringArray = (value: unknown): string[] => {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map(item => String(item || '').trim())
+    .filter(Boolean);
+};
+
+export const normalizeVisibilityRules = (value: unknown): VisibilityRules => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {
+      enabled: false,
+      authState: 'all',
+      allowedBreakpoints: [],
+      allowedLocales: [],
+      allowedCurrencies: [],
+      pathnameMatchType: 'any',
+      pathnameValue: '',
+      queryParamKey: '',
+      queryParamValue: ''
+    };
+  }
+
+  const rules = value as Record<string, unknown>;
+  return {
+    enabled: rules.enabled === true,
+    authState:
+      rules.authState === 'authenticated' || rules.authState === 'guest'
+        ? rules.authState
+        : 'all',
+    allowedBreakpoints: normalizeStringArray(rules.allowedBreakpoints),
+    allowedLocales: normalizeStringArray(rules.allowedLocales),
+    allowedCurrencies: normalizeStringArray(rules.allowedCurrencies).map(item =>
+      item.toUpperCase()
+    ),
+    pathnameMatchType:
+      rules.pathnameMatchType === 'equals' ||
+      rules.pathnameMatchType === 'contains' ||
+      rules.pathnameMatchType === 'startsWith'
+        ? rules.pathnameMatchType
+        : 'any',
+    pathnameValue: String(rules.pathnameValue || '').trim(),
+    queryParamKey: String(rules.queryParamKey || '').trim(),
+    queryParamValue: String(rules.queryParamValue || '').trim()
+  };
+};
+
+export const evaluateVisibilityRules = (
+  rawRules: unknown,
+  context: VisibilityRuleContext
+): boolean => {
+  const rules = normalizeVisibilityRules(rawRules);
+  if (!rules.enabled) return true;
+
+  if (rules.authState && rules.authState !== 'all') {
+    if (context.authState === 'loading') return false;
+    if (rules.authState === 'authenticated') {
+      if (context.authState !== 'authenticated') return false;
+    } else if (context.authState !== 'guest') {
+      return false;
+    }
+  }
+
+  if (
+    rules.allowedBreakpoints &&
+    rules.allowedBreakpoints.length > 0 &&
+    !rules.allowedBreakpoints.includes(context.breakpoint)
+  ) {
+    return false;
+  }
+
+  if (
+    rules.allowedLocales &&
+    rules.allowedLocales.length > 0 &&
+    !rules.allowedLocales.includes(context.locale)
+  ) {
+    return false;
+  }
+
+  if (
+    rules.allowedCurrencies &&
+    rules.allowedCurrencies.length > 0 &&
+    !rules.allowedCurrencies.includes(String(context.currency || '').toUpperCase())
+  ) {
+    return false;
+  }
+
+  const pathname = String(context.pathname || '');
+  if (rules.pathnameMatchType && rules.pathnameMatchType !== 'any') {
+    const ruleValue = String(rules.pathnameValue || '').trim();
+    if (!ruleValue) return false;
+
+    if (rules.pathnameMatchType === 'equals' && pathname !== ruleValue) {
+      return false;
+    }
+
+    if (
+      rules.pathnameMatchType === 'contains' &&
+      !pathname.includes(ruleValue)
+    ) {
+      return false;
+    }
+
+    if (
+      rules.pathnameMatchType === 'startsWith' &&
+      !pathname.startsWith(ruleValue)
+    ) {
+      return false;
+    }
+  }
+
+  if (rules.queryParamKey) {
+    const actualValue = context.searchParams?.get(rules.queryParamKey) ?? null;
+    if (actualValue === null) return false;
+    if (rules.queryParamValue && actualValue !== rules.queryParamValue) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const applyBlockVisibility = (
+  block: Block,
+  context: VisibilityRuleContext
+): Block => {
+  const blocks = block.blocks?.map(child => applyBlockVisibility(child, context));
+  const isVisibleByRules = evaluateVisibilityRules(
+    block.properties?.visibilityRules,
+    context
+  );
+
+  return {
+    ...block,
+    hidden: Boolean(block.hidden) || !isVisibleByRules,
+    blocks
+  };
+};
+
+export const applyVisibilityRulesToSections = (
+  sections: Section[],
+  context: VisibilityRuleContext
+): Section[] =>
+  sections.map(section => {
+    const blocks = section.blocks.map(block => applyBlockVisibility(block, context));
+    const isVisibleByRules = evaluateVisibilityRules(
+      section.properties?.visibilityRules,
+      context
+    );
+
+    return {
+      ...section,
+      hidden: Boolean(section.hidden) || !isVisibleByRules,
+      blocks
+    };
+  });