@controleonline/ui-common 1.2.70

package/src/react/utils/deviceRuntime.js

@@ -0,0 +1,193 @@
+import {Platform} from 'react-native';
+import {buildScreenMetrics} from '@controleonline/ui-common/src/react/utils/screenMetrics';
+
+const APP_TYPE_DEVICE_MAP = {
+  POS: 'PDV',
+  PPC: 'DISPLAY',
+  DISPLAY: 'DISPLAY',
+  KDS: 'KDS',
+  PRINT: 'PRINT',
+  PRINTER: 'PRINT',
+  TOTEM: 'DISPLAY',
+};
+
+export const WEB_DEVICE_INSTANCE_STORAGE_KEY = 'web-device-instance-id';
+
+const safeTrim = value => String(value || '').trim();
+const isPlainObject = value =>
+  !!value && typeof value === 'object' && !Array.isArray(value);
+const normalizeWebUserId = userId => safeTrim(userId).replace(/^web-/, '');
+
+const resolveStoredWebUserId = () => {
+  if (typeof localStorage === 'undefined') {
+    return '';
+  }
+
+  try {
+    const sessionData = JSON.parse(localStorage.getItem('session') || '{}');
+    return normalizeWebUserId(sessionData?.id || '');
+  } catch {
+    return '';
+  }
+};
+
+const safeStringify = value => {
+  try {
+    return JSON.stringify(value || {});
+  } catch {
+    return '{}';
+  }
+};
+
+const createWebDeviceInstanceId = () => {
+  const normalizedUserId = resolveStoredWebUserId();
+  if (!normalizedUserId) {
+    return '';
+  }
+
+  return `web-${normalizedUserId}`;
+};
+
+export const getOrCreateWebDeviceInstanceId = () => {
+  const nextId = createWebDeviceInstanceId();
+  if (!nextId) {
+    return '';
+  }
+
+  if (typeof localStorage === 'undefined') {
+    return nextId;
+  }
+
+  try {
+    localStorage.setItem(WEB_DEVICE_INSTANCE_STORAGE_KEY, nextId);
+    return nextId;
+  } catch {
+    return nextId;
+  }
+};
+
+export const isWebRuntimeDevice = deviceInfo =>
+  deviceInfo?.deviceType === 'web' ||
+  deviceInfo?.systemName === 'web' ||
+  String(deviceInfo?.id || '').startsWith('web-');
+
+export const resolveOperationalDeviceType = ({appType, deviceInfo}) => {
+  const normalizedAppType = safeTrim(appType).toUpperCase();
+  if (APP_TYPE_DEVICE_MAP[normalizedAppType]) {
+    return APP_TYPE_DEVICE_MAP[normalizedAppType];
+  }
+
+  if (normalizedAppType) {
+    return normalizedAppType;
+  }
+
+  if (safeTrim(deviceInfo?.type)) {
+    return safeTrim(deviceInfo.type).toUpperCase();
+  }
+
+  if (isWebRuntimeDevice(deviceInfo)) {
+    return 'WEB';
+  }
+
+  return 'DEVICE';
+};
+
+export const buildDeviceAlias = ({deviceInfo, appType}) => {
+  const resolvedType = resolveOperationalDeviceType({appType, deviceInfo});
+  return (
+    safeTrim(deviceInfo?.alias) ||
+    safeTrim(deviceInfo?.appName) ||
+    safeTrim(deviceInfo?.model) ||
+    safeTrim(deviceInfo?.manufacturer) ||
+    safeTrim(deviceInfo?.id) ||
+    resolvedType
+  );
+};
+
+export const buildDeviceMetadata = ({deviceInfo, appType}) => {
+  const screen = buildScreenMetrics();
+  const existingMetadata = isPlainObject(deviceInfo?.metadata)
+    ? deviceInfo.metadata
+    : {};
+  const navigatorData =
+    typeof navigator !== 'undefined'
+      ? {
+          userAgent: navigator.userAgent || null,
+          language: navigator.language || null,
+        }
+      : {};
+  const publicIp = safeTrim(deviceInfo?.externalIp) || null;
+
+  return {
+    runtime: Platform.OS,
+    appType: safeTrim(appType).toUpperCase() || null,
+    app: {
+      name: safeTrim(deviceInfo?.appName) || null,
+      version: safeTrim(deviceInfo?.appVersion) || null,
+      buildNumber: safeTrim(deviceInfo?.buildNumber) || null,
+    },
+    screen: {
+      deviceResolution: screen?.deviceResolution || null,
+      actualSize: screen?.actualSize || null,
+      windosSize: screen?.windosSize || null,
+    },
+    network: {
+      publicIp,
+    },
+    system: {
+      name: safeTrim(deviceInfo?.systemName) || null,
+      version: safeTrim(deviceInfo?.systemVersion) || null,
+      manufacturer: safeTrim(deviceInfo?.manufacturer) || null,
+      model: safeTrim(deviceInfo?.model) || null,
+      hardwareType: safeTrim(deviceInfo?.deviceType) || null,
+      isEmulator:
+        deviceInfo?.isEmulator === undefined ? null : !!deviceInfo.isEmulator,
+      batteryLevel:
+        deviceInfo?.batteryLevel === undefined ||
+        deviceInfo?.batteryLevel === null
+          ? null
+          : Number(deviceInfo.batteryLevel),
+    },
+    browser: navigatorData,
+    ...Object.fromEntries(
+      Object.entries(existingMetadata).filter(([key]) =>
+        !['runtime', 'appType', 'app', 'screen', 'network', 'system', 'browser'].includes(key),
+      ),
+    ),
+  };
+};
+
+export const buildLocalRuntimeDevice = ({deviceInfo, appType}) => {
+  const metadata = buildDeviceMetadata({deviceInfo, appType});
+  return {
+    ...deviceInfo,
+    type: resolveOperationalDeviceType({appType, deviceInfo}),
+    metadata,
+  };
+};
+
+export const buildDeviceRegistrationPayload = ({
+  deviceInfo,
+  appType,
+  existingDevice = null,
+}) => {
+  const localDevice = buildLocalRuntimeDevice({deviceInfo, appType});
+  return {
+    id: existingDevice?.id,
+    device: localDevice.id,
+    alias: existingDevice?.alias || buildDeviceAlias({deviceInfo: localDevice, appType}),
+    metadata: localDevice.metadata,
+  };
+};
+
+export const hasDeviceRecordChanges = ({existingDevice, nextDevice}) => {
+  if (!existingDevice) {
+    return true;
+  }
+
+  return (
+    safeTrim(existingDevice.device) !== safeTrim(nextDevice.device) ||
+    safeTrim(existingDevice.alias) !== safeTrim(nextDevice.alias) ||
+    safeStringify(existingDevice.metadata) !== safeStringify(nextDevice.metadata)
+  );
+};

package/src/react/utils/entityDisplay.js

@@ -0,0 +1,231 @@
+const pickFirstText = (...values) => {
+  for (const value of values) {
+    const normalized = normalizeText(value);
+    if (normalized) {
+      return normalized;
+    }
+  }
+
+  return '';
+};
+
+export const normalizeText = value => {
+  if (value === null || value === undefined) return '';
+
+  if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'bigint' ||
+    typeof value === 'boolean'
+  ) {
+    return String(value).trim();
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const normalized = normalizeText(item);
+      if (normalized) return normalized;
+    }
+    return '';
+  }
+
+  if (typeof value === 'object') {
+    const street = String(
+      value?.street_name ||
+      value?.streetName ||
+      value?.street ||
+      value?.logradouro ||
+      '',
+    ).trim();
+    const number = String(
+      value?.street_number ||
+      value?.streetNumber ||
+      value?.number ||
+      value?.house_number ||
+      '',
+    ).trim();
+    const streetLine = [street, number].filter(Boolean).join(', ');
+
+    const candidates = [
+      value?.display,
+      value?.formattedAddress,
+      value?.formatted_address,
+      value?.formatted,
+      value?.address,
+      value?.poi_address,
+      value?.value,
+      value?.description,
+      streetLine,
+      value?.district,
+      value?.city,
+      value?.name,
+      value?.reference,
+      value?.complement,
+    ];
+
+    for (const candidate of candidates) {
+      const normalized = normalizeText(candidate);
+      if (normalized) return normalized;
+    }
+  }
+
+  return '';
+};
+
+export const formatHumanLabel = value => {
+  const normalized = normalizeText(value)
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  if (!normalized) {
+    return '';
+  }
+
+  return normalized.replace(
+    /(^|[\s([{'"“”‘’])(\p{L})/gu,
+    (match, prefix, char) => `${prefix}${char.toLocaleUpperCase('pt-BR')}`,
+  );
+};
+
+export const uppercaseText = (value, locale = 'pt-BR') => {
+  if (value === null || value === undefined) {
+    return '';
+  }
+
+  const normalized = String(value);
+
+  try {
+    return normalized.toLocaleUpperCase(locale);
+  } catch {
+    return normalized.toUpperCase();
+  }
+};
+
+export const formatDisplayUppercase = (value, locale = 'pt-BR') => {
+  const normalized = normalizeText(value);
+
+  if (!normalized) {
+    return '';
+  }
+
+  return uppercaseText(normalized, locale);
+};
+
+export const formatPhoneDisplay = phoneEntry => {
+  if (!phoneEntry) return '';
+
+  if (typeof phoneEntry === 'string' || typeof phoneEntry === 'number') {
+    return normalizeText(phoneEntry);
+  }
+
+  const ddi = normalizeText(phoneEntry?.ddi);
+  const ddd = normalizeText(phoneEntry?.ddd);
+  const phone = normalizeText(phoneEntry?.phone);
+
+  if (!phone) return '';
+
+  return [ddi ? `+${ddi}` : '', ddd ? `(${ddd})` : '', phone]
+    .filter(Boolean)
+    .join(' ')
+    .trim();
+};
+
+export const resolveAddressDisplayParts = address => {
+  const streetName = normalizeText(address?.street?.street);
+  const streetNumber = normalizeText(address?.number);
+  const nickname = normalizeText(address?.nickname);
+  const complement = normalizeText(address?.complement);
+  const district = normalizeText(address?.street?.district?.district);
+  const city = normalizeText(address?.street?.district?.city?.city);
+  const state = normalizeText(
+    address?.street?.district?.city?.state?.uf ||
+    address?.street?.district?.city?.state?.state,
+  );
+  const postalCode = normalizeText(address?.street?.cep?.cep);
+
+  return {
+    primary: pickFirstText(
+      [streetName, streetNumber].filter(Boolean).join(', '),
+      streetName,
+      nickname,
+    ),
+    secondary: [district, [city, state].filter(Boolean).join(' / ')].filter(Boolean).join(' • '),
+    streetLine: [streetName, streetNumber].filter(Boolean).join(', '),
+    district,
+    cityStateLine: [city, state].filter(Boolean).join(' / '),
+    postalCode,
+    complement,
+    nickname,
+  };
+};
+
+export const buildAddressOptionSummary = address => {
+  const addressParts = resolveAddressDisplayParts(address);
+
+  return {
+    primary: pickFirstText(
+      addressParts.primary,
+      addressParts.streetLine,
+      addressParts.nickname,
+    ),
+    secondary: pickFirstText(
+      addressParts.secondary,
+      addressParts.postalCode,
+      addressParts.complement,
+    ),
+  };
+};
+
+export const buildCustomerSearchMeta = customer => {
+  const phone = pickFirstText(
+    Array.isArray(customer?.phone)
+      ? customer.phone.map(formatPhoneDisplay).find(Boolean)
+      : formatPhoneDisplay(customer?.phone),
+  );
+  const email = pickFirstText(
+    Array.isArray(customer?.email)
+      ? customer.email.map(item => normalizeText(item?.email)).find(Boolean)
+      : normalizeText(customer?.email?.email || customer?.email),
+  );
+  const document = pickFirstText(
+    Array.isArray(customer?.document)
+      ? customer.document.map(item => normalizeText(item?.document)).find(Boolean)
+      : normalizeText(customer?.document?.document || customer?.document),
+  );
+  const address = pickFirstText(
+    Array.isArray(customer?.address)
+      ? customer.address
+        .map(item => {
+          const summary = buildAddressOptionSummary(item);
+
+          return pickFirstText(
+            item?.search_for,
+            summary.primary,
+            summary.secondary,
+          );
+        })
+        .find(Boolean)
+      : '',
+  );
+
+  return [phone, email, document, address].filter(Boolean).join(' • ');
+};
+
+export const normalizePostalCodeInput = value =>
+  String(value ?? '')
+    .replace(/\D+/g, '')
+    .slice(0, 8);
+
+export const createEmptyAddressForm = (overrides = {}) => ({
+  nickname: '',
+  cep: '',
+  street: '',
+  number: '',
+  district: '',
+  city: '',
+  state: '',
+  country: 'Brasil',
+  complement: '',
+  ...overrides,
+});