sync-utils.js

(function(root, factory) {
  const api = factory();
  if (typeof module !== 'undefined' && module.exports) {
    module.exports = api;
  }
  root.RentMapSyncUtils = api;
})(typeof globalThis !== 'undefined' ? globalThis : this, function() {
  function mapPropertyToRecord(prop, userId) {
    const scoreRaw = prop.score;
    const scoreNum = scoreRaw == null || scoreRaw === '' ? null : Number(scoreRaw);
    return {
      id: prop.id,
      user_id: userId,
      title: prop.title || null,
      address: prop.address || null,
      price: prop.price ?? null,
      area: prop.area ?? null,
      room_type: prop.roomType || null,
      decor: prop.decor || null,
      layout: prop.layout || null,
      pet: prop.pet || null,
      parking: prop.parking || null,
      notes: prop.notes || null,
      source_text: prop.sourceText || null,
      status: prop.status || 'new',
      score: Number.isFinite(scoreNum) ? scoreNum : null,
      tags_json: Array.isArray(prop.tags) ? prop.tags : [],
      client_updated_at: prop.clientUpdatedAt || null,
      starred: !!prop.starred,
      lng: prop.lng ?? null,
      lat: prop.lat ?? null,
      commute_json: prop.commute || {},
    };
  }

  function mapPropertyFromRecord(row) {
    const scoreRaw = row.score;
    const scoreNum = scoreRaw == null || scoreRaw === '' ? null : Number(scoreRaw);
    return {
      id: row.id,
      title: row.title,
      address: row.address,
      price: row.price,
      area: row.area,
      roomType: row.room_type,
      decor: row.decor,
      layout: row.layout,
      pet: row.pet,
      parking: row.parking,
      notes: row.notes,
      sourceText: row.source_text || null,
      status: row.status || 'new',
      score: Number.isFinite(scoreNum) ? scoreNum : null,
      tags: Array.isArray(row.tags_json) ? row.tags_json : [],
      clientUpdatedAt: row.client_updated_at || null,
      updatedAt: row.updated_at || null,
      starred: !!row.starred,
      lng: row.lng,
      lat: row.lat,
      commute: row.commute_json || {},
    };
  }

  function mapDestinationToRecord(dest, userId) {
    return {
      id: dest.id,
      user_id: userId,
      name: dest.name || null,
      address: dest.address || null,
      lng: dest.lng ?? null,
      lat: dest.lat ?? null,
      mode: dest.mode || 'transit',
      active_mode: dest.activeMode || dest.mode || 'transit',
      reverse_dir: !!dest.reverseDir,
      color: dest.color || '#0F766E',
      client_updated_at: dest.clientUpdatedAt || null,
    };
  }

  function mapDestinationFromRecord(row) {
    return {
      id: row.id,
      name: row.name,
      address: row.address,
      lng: row.lng,
      lat: row.lat,
      mode: row.mode || 'transit',
      activeMode: row.active_mode || row.mode || 'transit',
      reverseDir: !!row.reverse_dir,
      color: row.color || '#0F766E',
      updatedAt: row.updated_at || null,
      clientUpdatedAt: row.client_updated_at || null,
    };
  }

  function shouldOfferCloudMigration(localProps, localDests, remoteProps, remoteDests) {
    const hasLocalData = (localProps?.length || 0) > 0 || (localDests?.length || 0) > 0;
    const hasRemoteData = (remoteProps?.length || 0) > 0 || (remoteDests?.length || 0) > 0;
    return hasLocalData && !hasRemoteData;
  }

  function hasMeaningfulLocalData(localProps, localDests, defaultDests) {
    if ((localProps?.length || 0) > 0) return true;
    if ((localDests?.length || 0) === 0) return false;
    if ((localDests?.length || 0) !== (defaultDests?.length || 0)) return true;

    return localDests.some((dest, idx) => {
      const baseline = defaultDests[idx] || {};
      return dest.name !== baseline.name || dest.address !== baseline.address;
    });
  }

  /** @param {'auto'|'paused'} policy */
  function shouldAllowAutoCloudSync(policy) {
    return policy !== 'paused';
  }

  /**
   * Pure decision for hydrate conflict UI outcomes.
   * @returns {{ applyRemote: boolean, uploadLocal: boolean, policy: 'auto'|'paused' }}
   */
  function resolveHydrateDecision(input) {
    const {
      shouldMigrate,
      migrateAccepted,
      localHasMeaningfulData,
      remoteHasData,
      useRemote,
      uploadLocalAccepted,
    } = input;

    if (shouldMigrate) {
      if (migrateAccepted) {
        return { applyRemote: false, uploadLocal: true, policy: 'auto' };
      }
      return { applyRemote: false, uploadLocal: false, policy: 'paused' };
    }

    if (localHasMeaningfulData && remoteHasData) {
      if (useRemote) {
        return { applyRemote: true, uploadLocal: false, policy: 'auto' };
      }
      if (uploadLocalAccepted) {
        return { applyRemote: false, uploadLocal: true, policy: 'auto' };
      }
      return { applyRemote: false, uploadLocal: false, policy: 'paused' };
    }

    if (remoteHasData) {
      return { applyRemote: true, uploadLocal: false, policy: 'auto' };
    }

    return { applyRemote: false, uploadLocal: false, policy: 'auto' };
  }

  function getRecordTimestamp(item) {
    if (!item || typeof item !== 'object') return 0;
    const raw = item.clientUpdatedAt || item.updatedAt || item.updated_at || item.client_updated_at || null;
    if (!raw) return 0;
    const t = Date.parse(raw);
    return Number.isFinite(t) ? t : 0;
  }

  /**
   * Merge local/remote arrays by id using timestamps (newer wins).
   * @param {object} [options]
   * @param {(item:any)=>any} [options.getId]
   * @param {Iterable<string>} [options.deletedIds] local intentional deletes (tombstones)
   * @returns {{ merged: any[], toUpload: any[], localOnly: any[], remoteOnly: any[], toDeleteRemote: any[] }}
   */
  function mergeByUpdatedAt(localItems, remoteItems, options = {}) {
    const idOf = typeof options.getId === 'function' ? options.getId : (x) => x?.id;
    const deletedIds = new Set(options.deletedIds || []);
    const map = new Map();

    for (const remote of remoteItems || []) {
      const id = idOf(remote);
      if (id == null) continue;
      map.set(id, { remote });
    }
    for (const local of localItems || []) {
      const id = idOf(local);
      if (id == null) continue;
      const entry = map.get(id) || {};
      entry.local = local;
      map.set(id, entry);
    }

    const merged = [];
    const toUpload = [];
    const localOnly = [];
    const remoteOnly = [];
    const toDeleteRemote = [];

    for (const [id, { local, remote }] of map) {
      if (deletedIds.has(id)) {
        // Local intentionally deleted — do not resurrect from cloud
        if (remote) toDeleteRemote.push(remote);
        continue;
      }
      if (local && remote) {
        const lt = getRecordTimestamp(local);
        const rt = getRecordTimestamp(remote);
        if (lt >= rt) {
          merged.push(local);
          toUpload.push(local);
        } else {
          merged.push(remote);
        }
      } else if (local) {
        merged.push(local);
        toUpload.push(local);
        localOnly.push(local);
      } else if (remote) {
        merged.push(remote);
        remoteOnly.push(remote);
      }
    }

    return { merged, toUpload, localOnly, remoteOnly, toDeleteRemote };
  }

  function rememberDeletedId(deletedIds, id) {
    if (id == null) return Array.isArray(deletedIds) ? deletedIds.slice() : [];
    const next = new Set(deletedIds || []);
    next.add(id);
    return [...next];
  }

  /** Alias: mark an id dirty for incremental upsert (same set semantics). */
  function markDirtyId(dirtyIds, id) {
    return rememberDeletedId(dirtyIds, id);
  }

  function forgetDeletedIds(deletedIds, ids) {
    if (!deletedIds?.length) return [];
    if (!ids?.length) return deletedIds.slice();
    const drop = new Set(ids);
    return deletedIds.filter((id) => !drop.has(id));
  }

  /**
   * Diff old→next item lists into tombstone updates.
   * @returns {{ deletedIds: string[] }}
   */
  function diffTombstones(oldItems, nextItems, deletedIds) {
    const nextIds = new Set((nextItems || []).map((x) => x?.id).filter((id) => id != null));
    let nextDeleted = Array.isArray(deletedIds) ? deletedIds.slice() : [];
    for (const item of oldItems || []) {
      const id = item?.id;
      if (id == null) continue;
      if (!nextIds.has(id)) nextDeleted = rememberDeletedId(nextDeleted, id);
    }
    nextDeleted = forgetDeletedIds(nextDeleted, [...nextIds]);
    return { deletedIds: nextDeleted };
  }

  /**
   * Local side has sync-relevant intent (data or pending deletes).
   */
  function hasLocalSyncIntent(input = {}) {
    const {
      props = [],
      dests = [],
      defaultDests = [],
      deletedPropIds = [],
      deletedDestIds = [],
    } = input;
    if ((deletedPropIds?.length || 0) > 0 || (deletedDestIds?.length || 0) > 0) return true;
    return hasMeaningfulLocalData(props, dests, defaultDests);
  }

  /**
   * Filter rows for incremental upsert (by dirty id set).
   * Empty dirty set → upsert nothing (caller still may push deletes).
   */
  function selectDirtyRows(rows, dirtyIds) {
    if (!rows?.length) return [];
    if (!dirtyIds || (Array.isArray(dirtyIds) ? dirtyIds.length === 0 : dirtyIds.size === 0)) {
      return [];
    }
    const set = dirtyIds instanceof Set ? dirtyIds : new Set(dirtyIds);
    return rows.filter((row) => set.has(row.id));
  }

  function mapTombstoneToRecord(entityType, entityId, userId) {
    return {
      user_id: userId,
      entity_type: entityType,
      entity_id: entityId,
    };
  }

  function partitionTombstones(rows) {
    const propIds = [];
    const destIds = [];
    for (const row of rows || []) {
      if (row.entity_type === 'property' && row.entity_id != null) propIds.push(row.entity_id);
      else if (row.entity_type === 'destination' && row.entity_id != null) destIds.push(row.entity_id);
    }
    return { propIds, destIds };
  }

  function mergeDeletedIdLists(...lists) {
    const set = new Set();
    for (const list of lists) {
      for (const id of list || []) {
        if (id != null) set.add(id);
      }
    }
    return [...set];
  }

  function entityTypeForTable(table) {
    if (table === 'properties') return 'property';
    if (table === 'destinations') return 'destination';
    return null;
  }

  return {
    mapPropertyToRecord,
    mapPropertyFromRecord,
    mapDestinationToRecord,
    mapDestinationFromRecord,
    hasMeaningfulLocalData,
    shouldOfferCloudMigration,
    shouldAllowAutoCloudSync,
    resolveHydrateDecision,
    getRecordTimestamp,
    mergeByUpdatedAt,
    rememberDeletedId,
    markDirtyId,
    forgetDeletedIds,
    diffTombstones,
    hasLocalSyncIntent,
    selectDirtyRows,
    mapTombstoneToRecord,
    partitionTombstones,
    mergeDeletedIdLists,
    entityTypeForTable,
  };
});