@recordtimelabel/core 0.4.6 → 0.5.0

package/src/domain/legacy.js

@@ -0,0 +1,359 @@
+import {digestCanonicalJson} from './hash.js';
+import {
+  SYSTEM_FOLDER_IDS,
+  VIRTUAL_FOLDER_IDS,
+  normalizeId,
+  normalizeIdList,
+  normalizeText,
+  toArray
+} from './shared.js';
+
+const EXCLUDED_LEGACY_RECORD_FIELDS = new Set([
+  'id',
+  'recordId',
+  'folderId',
+  'sortIndex',
+  'pendingSync',
+  'syncAttempts',
+  'pending',
+  'lastSyncError',
+  'syncStatus',
+  'clientId',
+  'ownerUid',
+  'workspaceEpoch',
+  'createdLocally',
+  'importedAt',
+  'lastSyncedAt',
+  'syncError'
+]);
+
+const FOLDER_REFERENCE_FIELDS = [
+  'folderId',
+  'originalFolderId',
+  'sourceFolderId',
+  'targetFolderId'
+];
+
+const OPERATION_TYPES = Object.freeze({
+  FOLDER_CREATE: 'folder.create',
+  FOLDER_UPDATE: 'folder.update',
+  FOLDER_DELETE: 'folder.delete',
+  FOLDER_REORDER: 'folder.reorder',
+  RECORD_CREATE: 'record.create',
+  RECORD_MOVE: 'record.move',
+  RECORD_REORDER: 'record.reorder',
+  SETTINGS_UPDATE: 'settings.update'
+});
+
+const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+const isSerializableDomainValue = (value) => {
+  const type = typeof value;
+  if (value === null) return true;
+  if (type === 'string' || type === 'boolean') return true;
+  if (type === 'number') return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isSerializableDomainValue);
+  if (isPlainObject(value)) return Object.values(value).every(isSerializableDomainValue);
+  return false;
+};
+
+const collectDomainRecordFields = (record = {}) => {
+  const fields = {};
+  Object.keys(record || {}).sort().forEach((key) => {
+    if (EXCLUDED_LEGACY_RECORD_FIELDS.has(key)) return;
+    if (key.startsWith('_') || key.startsWith('$')) return;
+    const value = record[key];
+    if (value === undefined || !isSerializableDomainValue(value)) return;
+    fields[key] = value;
+  });
+  return fields;
+};
+
+const resolveImportFolderId = (folderId, record = {}) => {
+  const candidates = [folderId, record.folderId, record.originalFolderId];
+  const match = candidates.map(normalizeId).find((id) => id && !VIRTUAL_FOLDER_IDS.has(id));
+  return match || 'uncategorized';
+};
+
+const isLegacyNameIdFolder = (folder = {}) => {
+  const id = normalizeId(folder?.id);
+  const name = normalizeText(folder?.name);
+  return Boolean(id) && !SYSTEM_FOLDER_IDS.has(id) && id === name;
+};
+
+const normalizeFolderName = (value) => normalizeText(value).toLowerCase();
+
+const buildLegacyFolderAliasMap = (folders = [], canonicalFolders = []) => {
+  const canonicalIdsByName = {};
+  toArray(canonicalFolders).forEach((folder) => {
+    const id = normalizeId(folder?.id);
+    const name = normalizeFolderName(folder?.name);
+    if (!id || !name || SYSTEM_FOLDER_IDS.has(id)) return;
+    const ids = canonicalIdsByName[name] || [];
+    if (!ids.includes(id)) ids.push(id);
+    canonicalIdsByName[name] = ids;
+  });
+
+  const aliases = {};
+  const diagnostics = {
+    remappedFolderCount: 0,
+    ambiguousFolderCount: 0,
+    unmatchedLegacyFolderCount: 0
+  };
+  toArray(folders).forEach((folder) => {
+    if (!isLegacyNameIdFolder(folder)) return;
+    const folderId = normalizeId(folder.id);
+    const candidates = canonicalIdsByName[normalizeFolderName(folder.name)] || [];
+    if (candidates.includes(folderId)) return;
+    if (candidates.length === 1) {
+      aliases[folderId] = candidates[0];
+      diagnostics.remappedFolderCount += 1;
+      return;
+    }
+    if (candidates.length === 0) diagnostics.unmatchedLegacyFolderCount += 1;
+    else diagnostics.ambiguousFolderCount += 1;
+  });
+  return {aliases, diagnostics};
+};
+
+const remapFolderId = (value, aliases = {}) => aliases[value] || value;
+
+const remapUniqueIds = (items = [], aliases = {}) => {
+  const seen = new Set();
+  return toArray(items).reduce((result, item) => {
+    const nextId = remapFolderId(item, aliases);
+    if (!nextId || seen.has(nextId)) return result;
+    seen.add(nextId);
+    result.push(nextId);
+    return result;
+  }, []);
+};
+
+const remapObjectFolderFields = (value, aliases = {}, fields = []) => {
+  if (!isPlainObject(value)) return value;
+  let result = value;
+  fields.forEach((field) => {
+    if (!Object.hasOwn(aliases, value[field])) return;
+    if (result === value) result = {...value};
+    result[field] = aliases[value[field]];
+  });
+  return result;
+};
+
+const remapRecordFolderFields = (record, aliases = {}) => (
+  remapObjectFolderFields(record, aliases, FOLDER_REFERENCE_FIELDS)
+);
+
+const remapRecordListFolderFields = (records, aliases = {}) => {
+  if (!Array.isArray(records)) return records;
+  let changed = false;
+  const remapped = records.map((record) => {
+    const nextRecord = remapRecordFolderFields(record, aliases);
+    if (nextRecord !== record) changed = true;
+    return nextRecord;
+  });
+  return changed ? remapped : records;
+};
+
+const remapPendingOperation = (operation, aliases = {}) => {
+  const payload = operation?.payload;
+  if (!isPlainObject(payload)) return operation;
+  let nextPayload = remapObjectFolderFields(payload, aliases, FOLDER_REFERENCE_FIELDS);
+  const setPayloadField = (field, value) => {
+    if (value === payload[field]) return;
+    if (nextPayload === payload) nextPayload = {...payload};
+    nextPayload[field] = value;
+  };
+
+  if ([
+    OPERATION_TYPES.FOLDER_CREATE,
+    OPERATION_TYPES.FOLDER_UPDATE,
+    OPERATION_TYPES.FOLDER_DELETE
+  ].includes(operation?.type)) {
+    setPayloadField('id', remapFolderId(payload.id, aliases));
+  }
+
+  setPayloadField('folder', remapObjectFolderFields(payload.folder, aliases, ['id']));
+  setPayloadField('record', remapRecordFolderFields(payload.record, aliases));
+  setPayloadField('records', remapRecordListFolderFields(payload.records, aliases));
+
+  if (operation?.type === OPERATION_TYPES.FOLDER_REORDER) {
+    setPayloadField('folderOrder', remapUniqueIds(payload.folderOrder, aliases));
+    setPayloadField('order', remapUniqueIds(payload.order, aliases));
+  }
+
+  if (operation?.type === OPERATION_TYPES.SETTINGS_UPDATE) {
+    setPayloadField('patch', remapObjectFolderFields(payload.patch, aliases, ['lastActiveFolderId']));
+    setPayloadField('settings', remapObjectFolderFields(payload.settings, aliases, ['lastActiveFolderId']));
+  }
+
+  return nextPayload === payload ? operation : {...operation, payload: nextPayload};
+};
+
+export const normalizeLegacyRecordTimeLabelImport = (input = {}) => {
+  const sourceRecords = input?.records && typeof input.records === 'object' ? input.records : {};
+  const generatedIds = [];
+  const occurrenceByDigest = {};
+  const nextRecords = {};
+  let assignedCount = 0;
+  let preservedCount = 0;
+
+  const visit = (folderId, record) => {
+    if (!record || typeof record !== 'object') return;
+    const resolvedFolderId = resolveImportFolderId(folderId, record);
+    if (!nextRecords[resolvedFolderId]) nextRecords[resolvedFolderId] = [];
+    const existingId = normalizeId(record.id || record.recordId);
+    if (existingId) {
+      preservedCount += 1;
+      nextRecords[resolvedFolderId].push({...record, id: existingId});
+      return;
+    }
+    const digest = digestCanonicalJson({
+      folderId: resolvedFolderId,
+      record: collectDomainRecordFields(record)
+    });
+    occurrenceByDigest[digest] = (occurrenceByDigest[digest] || 0) + 1;
+    const occurrence = occurrenceByDigest[digest];
+    const id = occurrence === 1
+      ? `legacy-record:${digest}`
+      : `legacy-record:${digest}:${occurrence}`;
+    assignedCount += 1;
+    generatedIds.push({folderId: resolvedFolderId, id, occurrence});
+    nextRecords[resolvedFolderId].push({...record, id});
+  };
+
+  if (Array.isArray(sourceRecords)) {
+    sourceRecords.forEach((record) => visit(record?.folderId, record));
+  } else {
+    Object.keys(sourceRecords).sort().forEach((folderId) => {
+      toArray(sourceRecords[folderId]).forEach((record) => visit(folderId, record));
+    });
+  }
+
+  return {
+    state: {
+      ...input,
+      records: nextRecords
+    },
+    generatedIds,
+    diagnostics: {
+      assignedCount,
+      preservedCount,
+      duplicateDigestCount: Object.values(occurrenceByDigest).filter((count) => count > 1).length
+    }
+  };
+};
+
+export const remapLegacyRecordTimeLabelFolderAliases = ({
+  state = {},
+  canonicalFolders = null,
+  pendingOperations = []
+} = {}) => {
+  const folders = toArray(state?.folders);
+  const canonical = canonicalFolders === null ? folders : toArray(canonicalFolders);
+  const {aliases, diagnostics} = buildLegacyFolderAliasMap(folders, canonical);
+  const aliasCount = Object.keys(aliases).length;
+  if (aliasCount === 0) {
+    return {
+      state,
+      pendingOperations: Array.isArray(pendingOperations) ? pendingOperations : [],
+      diagnostics: {
+        ...diagnostics,
+        remappedReferenceCount: 0
+      }
+    };
+  }
+
+  const nextFolders = folders.filter((folder) => !aliases[folder?.id]);
+  const folderIds = new Set(nextFolders.map((folder) => folder?.id).filter(Boolean));
+  const requiredCanonicalIds = new Set(Object.values(aliases));
+  canonical.forEach((folder) => {
+    if (!requiredCanonicalIds.has(folder?.id) || folderIds.has(folder.id)) return;
+    nextFolders.push(folder);
+    folderIds.add(folder.id);
+  });
+
+  const records = {};
+  const recordIdsByFolder = {};
+  Object.entries(state?.records || {}).forEach(([folderId, folderRecords]) => {
+    const targetFolderId = aliases[folderId] || folderId;
+    if (!records[targetFolderId]) records[targetFolderId] = [];
+    if (!recordIdsByFolder[targetFolderId]) recordIdsByFolder[targetFolderId] = new Set();
+    toArray(folderRecords).forEach((record) => {
+      const recordId = record?.id;
+      if (recordId && recordIdsByFolder[targetFolderId].has(recordId)) return;
+      if (recordId) recordIdsByFolder[targetFolderId].add(recordId);
+      records[targetFolderId].push(remapRecordFolderFields(record, aliases));
+    });
+  });
+
+  const settings = isPlainObject(state?.settings)
+    ? {
+        ...state.settings,
+        ...(aliases[state.settings.lastActiveFolderId]
+          ? {lastActiveFolderId: aliases[state.settings.lastActiveFolderId]}
+          : {})
+      }
+    : state?.settings;
+
+  const trashEntries = Object.fromEntries(
+    Object.entries(state?.trashEntries || {}).map(([entryId, entry]) => {
+      if (!isPlainObject(entry)) return [entryId, entry];
+      let nextEntry = remapObjectFolderFields(entry, aliases, ['originalFolderId']);
+      const payload = entry.payload;
+      if (isPlainObject(payload)) {
+        const nextRecord = remapRecordFolderFields(payload.record, aliases);
+        const nextRecords = remapRecordListFolderFields(payload.records, aliases);
+        if (nextRecord !== payload.record || nextRecords !== payload.records) {
+          nextEntry = {
+            ...nextEntry,
+            payload: {
+              ...payload,
+              ...(nextRecord !== payload.record ? {record: nextRecord} : {}),
+              ...(nextRecords !== payload.records ? {records: nextRecords} : {})
+            }
+          };
+        }
+      }
+      return [entryId, nextEntry];
+    })
+  );
+
+  const deletedRecordTombstones = Object.fromEntries(
+    Object.entries(state?.deletedRecordTombstones || {}).map(([recordId, tombstone]) => [
+      recordId,
+      remapObjectFolderFields(tombstone, aliases, ['folderId', 'originalFolderId'])
+    ])
+  );
+
+  const nextPendingOperations = (Array.isArray(pendingOperations) ? pendingOperations : []).reduce((result, operation) => {
+    const folderId = operation?.payload?.folder?.id || operation?.payload?.folderId;
+    if (operation?.type === OPERATION_TYPES.FOLDER_CREATE && aliases[folderId]) {
+      return result;
+    }
+    result.push(remapPendingOperation(operation, aliases));
+    return result;
+  }, []);
+
+  return {
+    state: {
+      ...state,
+      folders: nextFolders,
+      records,
+      folderOrder: remapUniqueIds(state?.folderOrder, aliases),
+      trashEntries,
+      deletedRecordTombstones,
+      deletedFolderTombstones: state?.deletedFolderTombstones,
+      lifecycleTombstones: state?.lifecycleTombstones,
+      ...(aliases[state?.lastActiveFolderId]
+        ? {lastActiveFolderId: aliases[state.lastActiveFolderId]}
+        : {}),
+      ...(settings ? {settings} : {})
+    },
+    pendingOperations: nextPendingOperations,
+    diagnostics: {
+      ...diagnostics,
+      remappedReferenceCount: aliasCount
+    }
+  };
+};

package/src/domain/shared.js

@@ -0,0 +1,132 @@
+export const GROUP_ID_PREFIX = 'group-';
+export const DEFAULT_UNKNOWN_TITLE = '未知直播標題';
+export const DEFAULT_UNKNOWN_CHANNEL = '未知頻道';
+export const VIRTUAL_FOLDER_IDS = new Set(['all']);
+export const SYSTEM_FOLDER_IDS = new Set(['all', 'uncategorized']);
+export const FALLBACK_PLATFORMS = new Set(['twitch', 'youtube', 'unknown']);
+export const TWITCH_STREAM_ANCHOR_TOLERANCE_MS = 5 * 60 * 1000;
+
+export const normalizeText = (value) => {
+  if (typeof value === 'string' || typeof value === 'number') {
+    return String(value).trim();
+  }
+  return '';
+};
+
+export const normalizeId = (value) => {
+  const text = normalizeText(value);
+  return text || '';
+};
+
+export const normalizeFallbackPlatform = (value) => {
+  const text = normalizeText(value).toLowerCase();
+  if (FALLBACK_PLATFORMS.has(text)) return text;
+  return 'unknown';
+};
+
+export const normalizeRecordPlatform = (record, fallbackPlatform) => {
+  const explicit = normalizeText(record?.platform).toLowerCase();
+  if (explicit === 'twitch' || explicit === 'youtube') return explicit;
+  if (explicit.includes('youtube') || explicit === 'yt') return 'youtube';
+  if (explicit.includes('twitch')) return 'twitch';
+  return normalizeFallbackPlatform(fallbackPlatform);
+};
+
+export const toArray = (value) => (Array.isArray(value) ? value : []);
+
+export const normalizeIdList = (ids = []) => {
+  const seen = new Set();
+  const result = [];
+  toArray(ids).forEach((id) => {
+    const normalized = normalizeId(id);
+    if (!normalized || seen.has(normalized)) return;
+    seen.add(normalized);
+    result.push(normalized);
+  });
+  return result;
+};
+
+export const getRecordUrls = (record = {}) => ([
+  record.videoUrl,
+  record.originalVideoUrl,
+  record.url,
+  record.sourceUrl,
+  record.jumpUrl
+].map(normalizeText).filter(Boolean));
+
+export const getFirstMatchingUrlValue = (record, extractor) => {
+  for (const url of getRecordUrls(record)) {
+    const value = extractor(url);
+    if (value) return value;
+  }
+  return '';
+};
+
+export const collectNonVirtualRecords = (records) => {
+  if (Array.isArray(records)) {
+    return records.filter((record) => record && typeof record === 'object');
+  }
+  if (!records || typeof records !== 'object') return [];
+  const collected = [];
+  Object.entries(records).forEach(([folderId, folderRecords]) => {
+    if (VIRTUAL_FOLDER_IDS.has(folderId)) return;
+    toArray(folderRecords).forEach((record) => {
+      if (record && typeof record === 'object') collected.push(record);
+    });
+  });
+  return collected;
+};
+
+export const extractYouTubeVideoIdFromUrl = (url) => {
+  const value = normalizeText(url);
+  if (!value) return '';
+
+  const shortMatch = value.match(/youtu\.be\/([^?&#/]+)/i);
+  if (shortMatch?.[1]) return shortMatch[1];
+
+  try {
+    const parsed = new URL(value);
+    if (parsed.hostname.includes('youtube.com')) {
+      const watchVideoId = normalizeText(parsed.searchParams.get('v'));
+      if (watchVideoId) return watchVideoId;
+      const parts = parsed.pathname.split('/').filter(Boolean);
+      if (['embed', 'shorts', 'live'].includes(parts[0])) {
+        return normalizeText(parts[1]);
+      }
+    }
+  } catch (_) {}
+
+  return '';
+};
+
+export const extractTwitchVodIdFromUrl = (url) => {
+  const value = normalizeText(url);
+  if (!value) return '';
+  const match = value.match(/twitch\.tv\/videos\/(\d+)/i) || value.match(/\/videos\/(\d+)/i);
+  return match?.[1] || '';
+};
+
+export const getRecordTitle = (record, unknownTitle = DEFAULT_UNKNOWN_TITLE) => (
+  normalizeText(record?.title) || unknownTitle
+);
+
+export const parseElapsedSeconds = (value) => {
+  if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+    return value;
+  }
+  const text = normalizeText(value);
+  if (!text) return null;
+  if (/^\d+(?:\.\d+)?$/.test(text)) {
+    const seconds = Number(text);
+    return Number.isFinite(seconds) && seconds >= 0 ? seconds : null;
+  }
+  const parts = text.split(':');
+  if (parts.length !== 2 && parts.length !== 3) return null;
+  if (!parts.every((part) => /^\d{1,2}$/.test(part))) return null;
+  const numbers = parts.map(Number);
+  if (!numbers.every(Number.isFinite)) return null;
+  if (parts.length === 3) {
+    return (numbers[0] * 3600) + (numbers[1] * 60) + numbers[2];
+  }
+  return (numbers[0] * 60) + numbers[1];
+};

package/src/domain/time.js

@@ -0,0 +1,43 @@
+const ISO_DATE_PATTERN = /^(\d{4}-\d{2}-\d{2})(?:[T\s](\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?)(Z|[+-]\d{2}:?\d{2})?)?$/;
+
+const normalizeIsoCandidate = (value) => {
+  const match = value.match(ISO_DATE_PATTERN);
+  if (!match) return '';
+  const date = match[1];
+  const time = match[2] || '00:00:00.000';
+  const offset = match[3] || 'Z';
+  const normalizedTime = time.length === 5 ? `${time}:00.000` : time.length === 8 ? `${time}.000` : time;
+  const normalizedOffset = offset === 'Z'
+    ? 'Z'
+    : offset.includes(':')
+      ? offset
+      : `${offset.slice(0, 3)}:${offset.slice(3)}`;
+  return `${date}T${normalizedTime}${normalizedOffset}`;
+};
+
+export const parseUtcMillis = (value) => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value !== 'string') return null;
+  const text = value.trim();
+  if (!text) return null;
+  if (/^-?\d+$/.test(text)) {
+    const numeric = Number(text);
+    return Number.isFinite(numeric) ? numeric : null;
+  }
+  const iso = normalizeIsoCandidate(text);
+  if (!iso) return null;
+  const millis = Date.parse(iso);
+  return Number.isFinite(millis) ? millis : null;
+};
+
+export const toCreatedAtMillis = (record) => {
+  const parsed = parseUtcMillis(record?.createdAt);
+  return parsed === null ? 0 : parsed;
+};
+
+export const roundDownToUtcMinuteIso = (millis) => {
+  if (!Number.isFinite(millis)) return '';
+  return new Date(Math.round(millis / 60000) * 60000).toISOString();
+};