@xleddyl/nuxt-cms 0.9.4 → 0.10.1

package/dist/runtime/shared/preview.js

@@ -7,11 +7,45 @@ import {
   isTranslatableField,
   isTranslatableMediaField,
   localizeBlocks,
+  blockAt,
+  blockListAt,
+  blockListPath,
+  blockPathIndex,
+  blockPathStartsWith,
+  blocksFieldAt,
+  canAddBlock,
+  formatBlockPath,
+  insertBlocks,
+  isBlockListPath,
+  mapBlocks,
+  parentBlockPath,
+  parseBlockPath,
+  sameBlockPath,
+  updateBlockAt,
+  walkBlocks,
+  mediaFilename,
   mediaPublicUrl,
   mediaTypeForKey,
   pickTranslatedMedia,
-  resolveBlocksMedia
+  resolveBlocksMedia,
+  linkDisplayText,
+  resolveCmsLink
 } from "./index.js";
+import { CMS_INLINE_TEXT_MAX_LENGTH } from "./inline-text.js";
+import { MAX_BLOCKS_DEPTH, isBlockItemPath, resolveBlockPath } from "./block-paths.js";
+import { blockSignature } from "./block-signature.js";
+function externalLinks(locale, defaultLocale) {
+  return (value) => resolveCmsLink({}, value, locale, defaultLocale);
+}
+function previewBlockLinks(field, items, resolveLink) {
+  return mapBlocks(field, items, (item, block) => {
+    const keys = Object.entries(block?.fields ?? {}).filter(([, blockField]) => blockField.type === "link").map(([key]) => key);
+    if (!keys.length) return item;
+    const resolved = { ...item };
+    for (const key of keys) resolved[key] = resolveLink(item[key]);
+    return resolved;
+  });
+}
 export const CMS_PREVIEW_CHANNEL = "nuxt-cms:preview";
 export const DEFAULT_CMS_PREVIEW_PATH = "/cms/preview";
 const RESERVED_ADMIN_SEGMENTS = /* @__PURE__ */ new Set(["login", "logout", "media"]);
@@ -26,48 +60,118 @@ export function previewPathErrors(path, entryNames) {
     return [`preview.path '${path}' clashes with an admin route, pick another segment`];
   return [];
 }
+const PREVIEW_THEMES = ["system", "light", "dark"];
+export function readPreviewTheme(value) {
+  return PREVIEW_THEMES.find((theme) => theme === value) ?? "system";
+}
+export const CMS_CLIPBOARD_MAX_LENGTH = 2e6;
 export function previewEnvelope(message) {
   return { ...message, channel: CMS_PREVIEW_CHANNEL };
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function isIndex(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+const FIELD_KEY = /^[a-z_]\w{0,99}$/i;
+export function isFieldKey(value) {
+  return typeof value === "string" && FIELD_KEY.test(value);
+}
+export function readMessagePath(value) {
+  if (!Array.isArray(value) || value.length > MAX_BLOCKS_DEPTH * 2) return null;
+  const valid = value.every(
+    (segment, position) => position % 2 === 0 ? isFieldKey(segment) : typeof segment === "number" && Number.isSafeInteger(segment) && segment >= 0
+  );
+  return valid && isBlockItemPath(value) ? [...value] : null;
+}
+function readOptionalPath(value) {
+  return value === null ? null : readMessagePath(value) ?? void 0;
 }
 function envelope(data) {
   if (!isRecord(data) || data.channel !== CMS_PREVIEW_CHANNEL) return null;
   return typeof data.type === "string" ? data : null;
 }
+const LOCALE_CODE = /^[a-z0-9_-]{1,35}$/i;
+function parseFieldInput(message) {
+  const path = readOptionalPath(message.path);
+  if (path === void 0 || !isFieldKey(message.key)) return null;
+  if (typeof message.locale !== "string" || !LOCALE_CODE.test(message.locale)) return null;
+  if (typeof message.value !== "string" || message.value.length > CMS_INLINE_TEXT_MAX_LENGTH)
+    return null;
+  return {
+    type: "field-input",
+    path,
+    key: message.key,
+    locale: message.locale,
+    value: message.value,
+    ...message.commit === true ? { commit: true } : {}
+  };
+}
+function parsePaste(message) {
+  const path = readMessagePath(message.path);
+  if (!path) return null;
+  if (message.text === void 0) return { type: "paste", path };
+  return typeof message.text === "string" && message.text.length <= CMS_CLIPBOARD_MAX_LENGTH ? { type: "paste", path, text: message.text } : null;
+}
 export function parseFrameMessage(data) {
   const message = envelope(data);
   if (!message) return null;
   const focus = message.focus === true ? { focus: true } : {};
   switch (message.type) {
     case "ready":
-      return { type: "ready" };
+    case "undo":
+    case "redo":
+    case "save":
+      return { type: message.type };
     case "select":
-      return message.index === null || isIndex(message.index) ? { type: "select", index: message.index, ...focus } : null;
-    case "move":
-      return isIndex(message.from) && isIndex(message.to) ? { type: "move", from: message.from, to: message.to, ...focus } : null;
+    case "hover": {
+      const path = readOptionalPath(message.path);
+      if (path === void 0) return null;
+      return message.type === "select" ? { type: "select", path, ...focus } : { type: "hover", path };
+    }
+    case "move": {
+      const from = readMessagePath(message.from);
+      const to = readMessagePath(message.to);
+      return from && to ? { type: "move", from, to, ...focus } : null;
+    }
     case "insert":
     case "duplicate":
     case "toggle-hidden":
     case "remove":
-      return isIndex(message.index) ? { type: message.type, index: message.index } : null;
+    case "copy":
+    case "cut": {
+      const path = readMessagePath(message.path);
+      return path ? { type: message.type, path } : null;
+    }
+    case "focus-field": {
+      const path = readOptionalPath(message.path);
+      return path !== void 0 && isFieldKey(message.key) ? { type: "focus-field", path, key: message.key } : null;
+    }
+    case "field-input":
+      return parseFieldInput(message);
+    case "paste":
+      return parsePaste(message);
     default:
       return null;
   }
 }
 export function parseHostMessage(data) {
   const message = envelope(data);
-  if (!message || message.type !== "render" || !isRecord(message.state)) return null;
+  if (!message) return null;
+  if (message.type === "highlight") {
+    const path = readOptionalPath(message.path);
+    return path === void 0 ? null : { type: "highlight", path };
+  }
+  if (message.type === "reveal") {
+    const path = readMessagePath(message.path);
+    return path ? { type: "reveal", path } : null;
+  }
+  if (message.type !== "render" || !isRecord(message.state)) return null;
   const state = message.state;
   if (typeof state.entry !== "string" || typeof state.field !== "string") return null;
   if (typeof state.locale !== "string" || !Array.isArray(state.blocks)) return null;
   if (state.item !== null && !isRecord(state.item)) return null;
   if (!isRecord(state.media)) return null;
-  if (state.selected !== null && !isIndex(state.selected)) return null;
+  const selected = readOptionalPath(state.selected);
+  if (selected === void 0) return null;
   return {
     type: "render",
     state: {
@@ -77,69 +181,118 @@ export function parseHostMessage(data) {
       blocks: state.blocks.filter(isRecord),
       item: state.item,
       media: state.media,
-      selected: state.selected
+      selected,
+      editable: state.editable !== false,
+      lockedFields: Array.isArray(state.lockedFields) ? state.lockedFields.filter((path) => typeof path === "string") : [],
+      theme: readPreviewTheme(state.theme)
     }
   };
 }
-export function isTrustedPreviewEvent(event, origin, source) {
-  return !!source && event.origin === origin && event.source === source;
+export function previewFieldConfig(target, blocksFields, blocksValues, entryFields, blocksKey) {
+  if (!isFieldKey(target.key)) return void 0;
+  if (target.path) {
+    const block = resolveBlockPath(blocksFields, blocksValues, target.path)?.block;
+    return block && Object.hasOwn(block.fields, target.key) ? block.fields[target.key] : void 0;
+  }
+  if (!entryFields || target.key === blocksKey || !Object.hasOwn(entryFields, target.key))
+    return void 0;
+  const field = entryFields[target.key];
+  return isPrivateField(field) ? void 0 : field;
 }
-function clamp(index, length) {
-  return Math.min(Math.max(index, 0), length);
+export function isApplePlatform(platform) {
+  return /mac|iphone|ipad|ipod/i.test(platform);
 }
-export function emptyBlock(type, block) {
-  return { type, ...Object.fromEntries(Object.keys(block.fields).map((key) => [key, null])) };
+export function editorShortcut(event, apple) {
+  if (event.altKey) return null;
+  const key = event.key.toLowerCase();
+  const mod = apple ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey;
+  if (mod) {
+    if (key === "z") return event.shiftKey ? "redo" : "undo";
+    if (event.shiftKey) return null;
+    if (key === "y") return "redo";
+    if (key === "s") return "save";
+    if (key === "d") return "duplicate";
+    if (key === "arrowup") return "move-up";
+    if (key === "arrowdown") return "move-down";
+    return null;
+  }
+  if (event.metaKey || event.ctrlKey) return null;
+  if (key === "enter") return event.shiftKey ? "insert-before" : "insert-after";
+  if (event.shiftKey) return null;
+  if (key === "delete" || key === "backspace") return "remove";
+  if (key === "escape") return "deselect";
+  return null;
 }
-export function insertBlock(list, index, item) {
-  const next = [...list];
-  next.splice(clamp(index, list.length), 0, item);
-  return next;
+export function shortcutApplies(action, target) {
+  if (action === "save") return true;
+  if (target.editable) return false;
+  if (action === "undo" || action === "redo") return true;
+  if (!target.selected) return false;
+  if (action === "deselect") return true;
+  return !target.interactive;
 }
-export function moveBlock(list, from, to) {
-  if (from === to || from < 0 || from >= list.length || to < 0 || to >= list.length)
-    return [...list];
-  const next = [...list];
-  const [item] = next.splice(from, 1);
-  next.splice(to, 0, item);
-  return next;
+export function clipboardActionApplies(action, target) {
+  if (target.editable) return false;
+  if (action === "paste") return true;
+  if (action === "cut" && target.interactive) return false;
+  return target.selected && !target.textSelected;
+}
+export function isTrustedPreviewEvent(event, origin, source) {
+  return !!source && event.origin === origin && event.source === source;
+}
+export function emptyBlock(type, block) {
+  const item = { type };
+  for (const [key, field] of Object.entries(block.fields))
+    item[key] = field.type === "blocks" ? starterBlocks(field) : null;
+  return item;
 }
-export function duplicateBlock(list, index) {
-  const item = list[index];
-  if (!item) return [...list];
-  return insertBlock(list, index + 1, JSON.parse(JSON.stringify(item)));
+function starterBlocks(field) {
+  const types = Object.entries(field.blocks ?? {});
+  const count = Math.min(field.min ?? 0, field.max ?? Number.POSITIVE_INFINITY);
+  if (types.length !== 1 || count < 1) return null;
+  const [type, block] = types[0];
+  return Array.from({ length: count }, () => emptyBlock(type, block));
 }
-export function removeBlock(list, index) {
-  return list.filter((_, i) => i !== index);
+export function duplicateBlockAt(values, path) {
+  const item = blockAt(values, path);
+  if (!item) return values;
+  const copy = JSON.parse(JSON.stringify(item));
+  return insertBlocks(values, blockListPath(path), blockPathIndex(path) + 1, [copy]);
 }
 export function canHideBlock(block) {
   return !!block && !declaresHiddenField(block);
 }
-export function toggleBlockHidden(list, index, block) {
-  const item = list[index];
-  if (!item || !canHideBlock(block)) return [...list];
-  const { [BLOCK_HIDDEN_KEY]: _hidden, ...rest } = item;
-  const updated = isHiddenBlock(item) ? rest : { ...rest, [BLOCK_HIDDEN_KEY]: true };
-  return list.map((current, i) => i === index ? updated : current);
+export function toggleBlockHiddenAt(values, path, block) {
+  if (!canHideBlock(block)) return values;
+  return updateBlockAt(values, path, (item) => {
+    const { [BLOCK_HIDDEN_KEY]: _hidden, ...rest } = item;
+    return isHiddenBlock(item) ? rest : { ...rest, [BLOCK_HIDDEN_KEY]: true };
+  });
 }
-export function selectionAfterMove(selected, from, to) {
-  if (selected === null) return null;
-  if (selected === from) return to;
-  if (from < selected && to >= selected) return selected - 1;
-  if (from > selected && to <= selected) return selected + 1;
-  return selected;
+export function canMoveBlock(fields, values, from, toList) {
+  const source = resolveBlockPath(fields, values, from);
+  if (!source?.block || !isBlockListPath(toList) || blockPathStartsWith(toList, from)) return false;
+  const target = blocksFieldAt(fields, values, toList);
+  const type = String(source.item.type);
+  const blocks = target?.blocks ?? {};
+  if (!target || !Object.hasOwn(blocks, type)) return false;
+  if (sameBlockPath(blockListPath(from), toList)) return true;
+  if (blockSignature(blocks[type]) !== blockSignature(source.block)) return false;
+  return canAddBlock(target, blockListAt(values, toList)?.length ?? 0);
 }
-export function selectionAfterRemove(selected, index) {
-  if (selected === null || selected === index) return null;
-  return selected > index ? selected - 1 : selected;
+export function isHorizontalList(boxes) {
+  return boxes.some((box, position) => {
+    const next = boxes[position + 1];
+    return !!next && next.left >= box.right - 1 && next.top < box.bottom - 1;
+  });
 }
-export function moveTargetForInsertion(from, insertAt) {
-  return insertAt > from ? insertAt - 1 : insertAt;
-}
-export function insertionIndex(blocks, y, total) {
-  for (const block of blocks) {
-    if (y < (block.top + block.bottom) / 2) return block.index;
+export function insertionIndex(boxes, point, total) {
+  const horizontal = isHorizontalList(boxes);
+  for (const box of boxes) {
+    const before = horizontal ? point.x < (box.left + box.right) / 2 : point.y < (box.top + box.bottom) / 2;
+    if (before) return box.index;
   }
-  const last = blocks[blocks.length - 1];
+  const last = boxes[boxes.length - 1];
   return last ? last.index + 1 : total;
 }
 function pushMediaKeys(keys, field, value) {
@@ -149,20 +302,11 @@ function pushMediaKeys(keys, field, value) {
 }
 export function collectMediaKeys(fields, values) {
   const keys = /* @__PURE__ */ new Set();
-  for (const [key, field] of Object.entries(fields)) {
-    const value = values?.[key];
-    if (field.type === "media") {
-      pushMediaKeys(keys, field, value);
-      continue;
-    }
-    if (field.type !== "blocks" || !Array.isArray(value)) continue;
-    for (const item of value) {
-      if (!isRecord(item)) continue;
-      const block = field.blocks?.[String(item.type)];
-      for (const [blockKey, blockField] of Object.entries(block?.fields ?? {}))
-        pushMediaKeys(keys, blockField, item[blockKey]);
-    }
-  }
+  for (const [key, field] of Object.entries(fields)) pushMediaKeys(keys, field, values?.[key]);
+  walkBlocks(fields, values, ({ item, block }) => {
+    for (const [blockKey, blockField] of Object.entries(block.fields))
+      pushMediaKeys(keys, blockField, item[blockKey]);
+  });
   return [...keys];
 }
 export function previewMedia(key, item, baseUrl) {
@@ -175,21 +319,37 @@ export function previewMedia(key, item, baseUrl) {
     mime: item?.mime ?? null,
     size: item?.size ?? null,
     width: item?.width ?? null,
-    height: item?.height ?? null
+    height: item?.height ?? null,
+    focalX: item?.focalX ?? null,
+    focalY: item?.focalY ?? null
   };
 }
-export function previewBlocks(field, value, locale, defaultLocale, media) {
+export function previewBlocks(field, value, locale, defaultLocale, media, resolveLink = externalLinks(locale, defaultLocale)) {
   if (!Array.isArray(value)) return [];
   const localized = localizeBlocks(field, value, locale, defaultLocale);
-  return resolveBlocksMedia(field, localized, (key) => media[key] ?? null);
+  const resolved = resolveBlocksMedia(field, localized, (key) => media[key] ?? null);
+  return previewNestedLists(
+    field,
+    previewBlockLinks(field, resolved, resolveLink)
+  );
+}
+function previewNestedLists(field, items) {
+  return mapBlocks(field, items, (item, block) => {
+    const empty = Object.entries(block?.fields ?? {}).filter(
+      ([key, nested]) => nested.type === "blocks" && !Array.isArray(item[key])
+    );
+    return empty.length ? { ...item, ...Object.fromEntries(empty.map(([key]) => [key, []])) } : item;
+  });
 }
-export function previewItem(fields, values, locale, defaultLocale, media) {
+export function previewItem(fields, values, locale, defaultLocale, media, resolveLink = externalLinks(locale, defaultLocale)) {
   const item = {};
   for (const [key, field] of Object.entries(fields)) {
     if (isPrivateField(field)) continue;
     const value = values[key] ?? null;
     if (field.type === "blocks") {
-      item[key] = previewBlocks(field, value, locale, defaultLocale, media);
+      item[key] = previewBlocks(field, value, locale, defaultLocale, media, resolveLink);
+    } else if (field.type === "link") {
+      item[key] = resolveLink(value);
     } else if (field.type === "media") {
       const mediaKey = isTranslatableMediaField(field) ? pickTranslatedMedia(
         decodeTranslatableValue(value, defaultLocale),
@@ -206,14 +366,192 @@ export function previewItem(fields, values, locale, defaultLocale, media) {
   }
   return item;
 }
-export function blockSummary(block, item, locale, defaultLocale, max = 80) {
+const SUMMARY_FIELD_TYPES = /* @__PURE__ */ new Set(["text", "richtext", "email"]);
+const HTML_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  "#39": "'"
+};
+function plainText(value) {
+  return value.replace(/<[^>]*>/g, " ").replace(/&(amp|lt|gt|quot|apos|nbsp|#39);/g, (_, name) => HTML_ENTITIES[name]).replace(/\s+/g, " ").trim();
+}
+function localizedText(raw, locale, defaultLocale) {
+  if (typeof raw === "string") return raw;
+  if (!isRecord(raw)) return "";
+  const value = raw[locale] || raw[defaultLocale];
+  return typeof value === "string" ? value : "";
+}
+function blockMediaName(block, item, locale, defaultLocale) {
   for (const [key, field] of Object.entries(block?.fields ?? {})) {
-    if (field.type !== "text" && field.type !== "richtext") continue;
+    if (field.type !== "media") continue;
     const raw = item[key];
-    const translations = isRecord(raw) ? raw : null;
-    const value = typeof raw === "string" ? raw : translations?.[locale] || translations?.[defaultLocale] || "";
-    const text = value.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
-    if (text) return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+    const value = isTranslatableMediaField(field) ? pickTranslatedMedia(decodeTranslatableValue(raw, defaultLocale), locale, defaultLocale) : raw;
+    if (typeof value === "string" && value) return mediaFilename(value);
   }
   return "";
 }
+export function blockSummary(block, item, locale, defaultLocale, max = 80) {
+  let text = "";
+  for (const [key, field] of Object.entries(block?.fields ?? {})) {
+    if (field.type === "link") {
+      text = linkDisplayText(item[key], locale, defaultLocale).trim();
+      if (text) break;
+      continue;
+    }
+    if (!SUMMARY_FIELD_TYPES.has(field.type)) continue;
+    text = plainText(localizedText(item[key], locale, defaultLocale));
+    if (text) break;
+  }
+  if (!text) text = blockMediaName(block, item, locale, defaultLocale);
+  if (!text) text = nestedBlockSummary(block, item, locale, defaultLocale, max);
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+function nestedBlockSummary(block, item, locale, defaultLocale, max) {
+  let count = 0;
+  for (const [key, field] of Object.entries(block?.fields ?? {})) {
+    const list = item[key];
+    if (field.type !== "blocks" || !Array.isArray(list)) continue;
+    for (const child of list) {
+      if (!isRecord(child)) continue;
+      count++;
+      const text = blockSummary(
+        field.blocks?.[String(child.type)],
+        child,
+        locale,
+        defaultLocale,
+        max
+      );
+      if (text) return text;
+    }
+  }
+  return count ? `${count} ${count === 1 ? "block" : "blocks"}` : "";
+}
+function itemPrefixes(segments) {
+  const prefixes = [];
+  for (let end = 2; end <= segments.length; end += 2) {
+    if (!/^\d+$/.test(segments[end - 1])) break;
+    prefixes.push(segments.slice(0, end).join("."));
+  }
+  return prefixes;
+}
+export function blockErrorPaths(errors, fieldKey) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const [key, message] of Object.entries(errors)) {
+    if (!message || !key.startsWith(`${fieldKey}.`)) continue;
+    for (const prefix of itemPrefixes(key.split("."))) paths.add(prefix);
+  }
+  return paths;
+}
+function compareErrorKeys(a, b) {
+  const left = a.split(".");
+  const right = b.split(".");
+  for (let position = 0; position < Math.min(left.length, right.length); position++) {
+    const x = left[position];
+    const y = right[position];
+    if (x === y) continue;
+    if (/^\d+$/.test(x) && /^\d+$/.test(y)) return Number(x) - Number(y);
+    return 0;
+  }
+  return left.length - right.length;
+}
+export function firstBlockError(errors, fieldKey) {
+  const keys = Object.keys(errors).filter((key) => errors[key] && key.startsWith(`${fieldKey}.`)).sort(compareErrorKeys);
+  for (const key of keys) {
+    const segments = key.split(".");
+    const deepest = itemPrefixes(segments).at(-1);
+    const path = deepest ? parseBlockPath(deepest) : null;
+    if (!path) continue;
+    const next = segments[path.length];
+    return next ? { path, key: next } : { path };
+  }
+  return null;
+}
+export function editorIssueKeys(fields, values, path, fieldKey) {
+  const [head] = path;
+  if (typeof head !== "string" && typeof head !== "number") return [];
+  const keys = [String(head)];
+  if (String(head) !== fieldKey || typeof path[1] !== "number") return keys;
+  let end = 2;
+  while (end <= MAX_BLOCKS_DEPTH * 2) {
+    const item = path.slice(0, end);
+    const next = path[end];
+    if (typeof next !== "string" && typeof next !== "number") {
+      keys.push(formatBlockPath(item));
+      break;
+    }
+    const block = resolveBlockPath(fields, values, item)?.block;
+    const field = block && Object.hasOwn(block.fields, next) ? block.fields[next] : void 0;
+    if (field?.type === "blocks" && typeof path[end + 1] === "number") {
+      end += 2;
+      continue;
+    }
+    keys.push(`${formatBlockPath(item)}.${String(next)}`);
+    break;
+  }
+  return keys;
+}
+export function blockTreeVisits(fields, values, prefix = []) {
+  const visits = [];
+  for (const [key, field] of Object.entries(fields)) {
+    const list = values?.[key];
+    if (field?.type !== "blocks" || !Array.isArray(list)) continue;
+    list.forEach((item, index) => {
+      if (!isRecord(item)) return;
+      const block = field.blocks?.[String(item.type)];
+      const path = [...prefix, key, index];
+      visits.push({ path, item, block, field });
+      if (block) visits.push(...blockTreeVisits(block.fields, item, path));
+    });
+  }
+  return visits;
+}
+function listKeyOf(path, ids) {
+  const parent = parentBlockPath(path);
+  const owner = parent ? ids.get(formatBlockPath(parent)) : "root";
+  return `${String(owner)}:${String(path.at(-2))}`;
+}
+function replacedId(before, item, index, present, used) {
+  let best;
+  before?.items.forEach((candidate, position) => {
+    const id = before.ids[position];
+    if (id === void 0 || used.has(id) || present.has(candidate)) return;
+    if (candidate.type !== item.type) return;
+    const distance = Math.abs(position - index);
+    if (!best || distance < best.distance) best = { id, distance };
+  });
+  return best?.id;
+}
+export function stableBlockTreeIds(visits, previous, createId) {
+  const present = new Set(visits.map((visit) => visit.item));
+  const used = /* @__PURE__ */ new Set();
+  const assigned = /* @__PURE__ */ new Map();
+  visits.forEach((visit, position) => {
+    const id = previous?.items.get(visit.item);
+    if (id === void 0 || used.has(id)) return;
+    used.add(id);
+    assigned.set(position, id);
+  });
+  const ids = /* @__PURE__ */ new Map();
+  const snapshot = { items: /* @__PURE__ */ new Map(), lists: /* @__PURE__ */ new Map() };
+  visits.forEach((visit, position) => {
+    const listKey = listKeyOf(visit.path, ids);
+    const index = blockPathIndex(visit.path);
+    let id = assigned.get(position);
+    if (id === void 0) {
+      id = replacedId(previous?.lists.get(listKey), visit.item, index, present, used);
+      id ??= createId();
+      used.add(id);
+    }
+    ids.set(formatBlockPath(visit.path), id);
+    if (!snapshot.items.has(visit.item)) snapshot.items.set(visit.item, id);
+    const list = snapshot.lists.get(listKey) ?? { items: [], ids: [] };
+    list.items[index] = visit.item;
+    list.ids[index] = id;
+    snapshot.lists.set(listKey, list);
+  });
+  return { ids, snapshot };
+}